import java.util.Scanner

case class Point(x: Double, y: Double) {
  def distanceTo(that: Point) = this.minus(that).norm
  def scale(c: Double) = Point(c*x, c*y)
  def add(that: Point) = that match { case Point(xx, yy) => Point(x+xx,y+yy) }
  def minus(that: Point) = add(that.scale(-1))
  def norm = math.sqrt(x*x+y*y)
  def normalized = this.scale(1.0/norm)
  def ortho = Point(y, -x)
}

object Point {
    def intersections(p1: Point, p2: Point, r: Double): Option[(Point, Point)] = {
    val m = p1.add(p2).scale(1.0/2)
    val h = p1.distanceTo(m)
    if (r > h) {
      val d = math.sqrt(r*r-h*h)
      val dv = p1.minus(p2).ortho.normalized.scale(d)
      Some((m.add(dv), m.minus(dv)))
    } else None
  }
}

case class Input(ps: List[Point]) {
  private def nearAll(from: Point, r: Double,
                      e1: Point, e2: Point): Boolean =
    ps.forall(p => p == e1 || p == e2 || from.distanceTo(p) <= r)
  private def ok(r: Double): Boolean = {
    val bs = for (List(p1, p2) <- ps.combinations(2)) yield
      Point.intersections(p1, p2, r) match {
        case None => false
        case Some((ip1, ip2)) => {
          nearAll(ip1, r, p1, p2) || nearAll(ip2, r, p1, p2)
        }
      }
    bs.exists(identity)
  }
  private def binsearch(lb: Double, ub: Double): Double = {
    if (ub - lb < math.pow(10, -7)) ub
    else {
      val m = (lb + ub) / 2
      if (ok(m)) binsearch(lb, m)
      else binsearch(m, ub)
    }
  }
  def solved: Output = {
    val ans = binsearch(0, 1500000)
    Output(ans)
  }
}

object Input {
  def fromStdin(): Input = {
    val sc = new Scanner(System.in)
    val n = sc.nextInt()
    def nextPoint() =  Point(sc.nextInt(), sc.nextInt())
    Input(List.fill(n)(nextPoint))
  }
}

case class Output(ans: Double) {
  override def toString(): String = {
    ans.toString()
  }

  def print() = println(this.toString())
}

object Main extends App {
  Input.fromStdin().solved.print()
}
