import scala.annotation.tailrec
import scala.collection.{immutable, mutable}

import scala.math._
object Main extends App {

  import scala.io.StdIn._
  loop()
  @tailrec def loop(): Unit = {
    val n = readInt
    val minDiff = 1e-12
    if (n == 0) return
    val shops = Array.fill(n){
      val Array(x, y, v) = readLine.trim.split(' ').map(_.toInt)
      SweetsShop(Point(x, y), v)
    }
    var min = 0d
    var max = 150d
    while (min + minDiff < max) {
      val mid = (min + max) / 2
      val circles = shops.map{_.reachableCircle(mid)}
      if ((circles.map{_.center} ++ circles.combinations(2).flatMap{a ⇒ a(0).crossPoints(a(1))}).exists(p ⇒ circles.forall(_.contains(p)))) {
        max = mid
      }else {
        min = mid
      }
    }
    println(f"$max%.10f")
    loop()
  }
  implicit class Wrap[T](val value: T) extends AnyVal {
    @inline def tap(func: T ⇒ Unit): T = {
      func(value)
      value
    }
  }
}
case class Angle(sin: Double, cos: Double) {
  def toRad(): Double = math.atan2(sin, cos)
  def +(that: Angle): Angle = Angle(sin * that.cos + cos * that.sin, cos * that.cos - sin * that.sin)
  def -(that: Angle): Angle = Angle(sin * that.cos - cos * that.sin, cos * that.cos + sin * that.sin)
  def unary_-(): Angle = Angle(-sin, cos)
}
object Angle {
  def fromRad(rad: Double): Angle = Angle(sin(rad), cos(rad))
}
case class Section(from: Double, to: Double) {
  def cutOff(that: Section): List[Section] = {
    if (that.to < from || to < that.from) List(this)
    else if (contains(that.from) && contains(that.to)) List(Section(from, that.from), Section(that.to, to))
    else if (that.contains(from) && that.contains(to)) Nil
    else if (contains(that.from)) List(Section(from, that.from))
    else List(Section(that.to, to))
  }
  def contains(that: Double): Boolean = from <= that && that <= to
  def length: Double = to - from
}
case class Point(x: Double, y: Double) {
  def +(that: Point): Point = Point(x + that.x, y + that.y)
  def -(that: Point): Point = Point(x - that.x, y - that.y)
  def toVec(): Vector = Vector(x, y)
  def shift(vec: Vector): Point = Point(x + vec.x, y + vec.y)
  def distanceFrom(that: Point): Double = (this - that).toVec().length
}
case class Vector(x: Double, y: Double) {
  def toAngle(): Angle = Angle.fromRad(atan2(y, x))
  def length: Double = sqrt(x * x + y * y)
}
case class Circle(center: Point, radius: Double) {
  def crossPoints(that: Circle): List[Point] = {
    val dist = center.distanceFrom(that.center)
    if (dist >= radius + that.radius || dist + min(radius, that.radius) <= max(radius, that.radius)) Nil
    else {
      val cos = (radius * radius + dist * dist - that.radius * that.radius) / 2 / radius / dist
      val angle = Angle(sqrt(1 - cos * cos), cos)
      val baseAngle = (that.center - center).toVec().toAngle()
      val pa = baseAngle - angle
      val pb = baseAngle + angle
      List(center + Point(pa.cos * radius, pa.sin * radius), center + Point(pb.cos * radius, pb.sin * radius))
    }
  }
  def contains(that: Circle): Boolean = {
    center.distanceFrom(that.center) + that.radius <= radius
  }
  def contains(that: Point): Boolean = {
    center.distanceFrom(that) <= radius + 1e-6
  }
}

case class SweetsShop(position: Point, velocity: Int) {
  def reachableCircle(time: Double): Circle = Circle(position, velocity * time)
}


Measured memory_bytes: 455272