import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}
import scala.collection.mutable.{Map, Stack, Queue, PriorityQueue, Set}

case class Coord(x: Double, y: Double) extends Ordered[Coord] {

  def this(p: (Double, Double)) = this(p._1, p._2)

  def compare(that: Coord): Int = {
    if (this.x != that.x)
      this.x.compare(that.x)
    else
      this.y.compare(that.y)
  }

  def +(co: Coord): Coord = {
    Coord(this.x + co.x, this.y + co.y)
  }

  def -(co: Coord): Coord = {
    Coord(this.x - co.x, this.y - co.y)
  }

  def toPair: (Double, Double) = (x, y)

  def dist(that: Coord): Double = {
    import Math.{sqrt, pow}
    sqrt(pow(this.x - that.x, 2) + pow(this.y - that.y, 2))
  }

  def moveTo(that: Coord, ratio: Double): Coord = {
    import Math.{sqrt, pow, abs}
    val dx = abs(x - that.x) * ratio
    val dy = abs(y - that.y) * ratio

    val gx =
      if (x > that.x) x - dx
      else x + dx
    val gy =
      if (y > that.y) y - dy
      else y + dy

    Coord(gx, gy)
  }

}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  val N = in.next().toInt
  val p = new Array[Coord](N)
  for (i <- 0 until N) {
    val x, y = in.next().toInt
    p(i) = Coord(x, y)
  }

  //
  var now = Coord(0.0, 0.0)
  for (n <- 1 to 1500000) {
    var hoge: Coord = null
    var maxDist = 0.0
    for (c <- p) {
      if (now.dist(c) > maxDist) {
        maxDist = now.dist(c)
        hoge = c
      }
    }

    now = now.moveTo(hoge, 1.0 / n)
  }

  var maxDist = 0.0
  for (c <- p) {
    if (now.dist(c) > maxDist) {
      maxDist = now.dist(c)
    }
  }

  println(maxDist)
}

object Sub {
  def print2DimArray[A](mat: Array[Array[A]]): Unit = {
    mat.foreach(lin => println(lin.deep))
  }
}

class InputReader(stream: InputStream) {
  private[this] val reader = new BufferedReader(new InputStreamReader(stream))
  private[this] var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}
