import scala.io.StdIn._
object Main extends App {
  val n = readInt()
  val points = Array.tabulate(n){_ ⇒
    val Array(x, y) = readLine.trim.split(' ').map(_.toDouble)
    Point(x, y)
  }
  val convex = new Convex(points)
  var s = 1
  var t = 2
  var min = Double.MaxValue
  for (f ← 0 until n) {
    val first = convex(f)
    while (!first.isOver120Degree(convex(s))) s += 1
    val second = convex(s)
    while (!first.isOver240Degree(convex(t))) t += 1
    val third = convex(t)
    val baseLine = Line(first.from, first.to)
    val firstAngle = first.angle
    val secondLine = Line(second.from, firstAngle + Angle.degree120)
    val thirdLine = Line(third.from, firstAngle + Angle.degree240)
    val len = baseLine.crossPoint(secondLine).flatMap{p ⇒ baseLine.crossPoint(thirdLine).map{q ⇒ p.distanceFrom(q)}}.get
    if (min > len) {
      //println(s"first: $first, second: $second, third: $third")
      //println(s"firstAngle: ${first.angle.toDegree}, secondAngle: ${second.angle.toDegree}, thirdAngle: ${third.angle.toDegree}")
      //println(len)
      min = len
    }
  }
  println(f"$min%.10f")
}
case class Point(x: Double, y: Double) {
  def distanceFrom(that: Point): Double = (this - that).length
  def -(that: Point): Vector = Vector(x - that.x, y - that.y)
}
case class Edge(from: Point, to: Point) {
  def isOver120Degree(that: Edge): Boolean = {
    val angle = (to - from).angleFrom(that.to - that.from)
    angle.sin < 0 || angle.cos <= -1.0 / 2
  }
  def isOver240Degree(that: Edge): Boolean = {
    val angle = (to - from).angleFrom(that.to - that.from)
    angle.sin <= 0.0000001 && angle.cos >= -1.0 / 2
  }
  def angle: Angle = {
    val diff = to - from
    Angle(diff.y / diff.length, diff.x / diff.length)
  }
}
object Angle {
  val degree120: Angle = Angle(math.sqrt(3) / 2, -1.0 / 2)
  val degree240: Angle = Angle(-math.sqrt(3) / 2, -1.0 / 2)
}
case class Angle(sin: Double, cos: Double) {
  def +(that: Angle): Angle = Angle(sin * that.cos + cos * that.sin, cos * that.cos - sin * that.sin)
  def toDegree: Double = {
    if (sin >= 0) math.acos(cos) / math.Pi * 180
    else 360 - math.acos(cos) / math.Pi * 180
  }
}
case class Vector(x: Double, y: Double) {
  def cross(that: Vector): Double = x * that.y - y * that.x
  def dot(that: Vector): Double = x * that.x + y * that.y
  def length: Double = math.sqrt(x * x + y * y)
  def angleFrom(that: Vector): Angle = {
    val a = length
    val b = that.length
    Angle(cross(that) / a / b, dot(that) / a / b)
  }
}
object Line {
  def apply(point: Point, angle: Angle): Line = {
    Line(angle.sin, -angle.cos, angle.cos * point.y - angle.sin * point.x)
  }
  def apply(a: Point, b: Point): Line = {
    val vec = a - b
    Line(vec.y, -vec.x, vec.x * b.y - vec.y * b.x)
  }
}
case class Line(a: Double, b: Double, c: Double) {
  def isParallel(that: Line): Boolean = math.abs(a * that.b - b * that.a) <= 0.0000001
  def crossPoint(that: Line): Option[Point] = {
    if (isParallel(that)) None
    else {
      val d = a * that.b - b * that.a
      Some(Point((b * that.c - c * that.b) / d, (c * that.a - a * that.c) / d))
    }
  }
  def angle: Angle = {
    val d = math.sqrt(a * a + b * b)
    Angle(a / d, -b / d)
  }
}
class RingArray[T](private val array: Array[T]) {
  def apply(index: Int): T = array(index % array.length)
}
class Convex(array: Array[Point]) {
  private val ring = new RingArray(array)
  def apply(index: Int): Edge = Edge(ring(index), ring(index + 1))
}


Measured memory_bytes: 85364