You know, it's hard to conduct a show with lots of participants and spectators at the same place nowadays. Still, you are not giving up on your dream to make a car crash showcase! You decided to replace the real cars with remote controlled ones, call the event "Remote Control Kaboom Show" and stream everything online.

For the preparation you arranged an arena — an infinite 2D-field. You also bought n remote controlled cars and set them up on the arena. Unfortunately, the cars you bought can only go forward without turning left, right or around. So you additionally put the cars in the direction you want them to go.

To be formal, for each car i (1 ≤ i ≤ n) you chose its initial position (x_i, y_i) and a direction vector (dx_i, dy_i). Moreover, each car has a constant speed s_i units per second. So after car i is launched, it stars moving from (x_i, y_i) in the direction (dx_i, dy_i) with constant speed s_i.

The goal of the show is to create a car collision as fast as possible! You noted that launching every car at the beginning of the show often fails to produce any collisions at all. Thus, you plan to launch the i-th car at some moment t_i. You haven't chosen t_i, that's yet to be decided. Note that it's not necessary for t_i to be integer and t_i is allowed to be equal to t_j for any i, j.

The show starts at time 0. The show ends when two cars i and j (i ≠ j) collide (i. e. come to the same coordinate at the same time). The duration of the show is the time between the start and the end.

What's the fastest crash you can arrange by choosing all t_i? If it's possible to arrange a crash then print the shortest possible duration of the show. Otherwise, report that it's impossible.

Input

The first line contains a single integer n (1 ≤ n ≤ 25000) — the number of cars.

Each of the next n lines contains five integers x_i, y_i, dx_i, dy_i, s_i (-10^3 ≤ x_i, y_i ≤ 10^3; 1 ≤ |dx_i| ≤ 10^3; 1 ≤ |dy_i| ≤ 10^3; 1 ≤ s_i ≤ 10^3) — the initial position of the i-th car, its direction vector and its speed, respectively.

It's guaranteed that all cars start at distinct positions (i. e. (x_i, y_i) ≠ (x_j, y_j) for i ≠ j).

Output

Print the shortest possible duration of the show if it's possible to arrange a crash by choosing all t_i. Otherwise, print "No show :(".

Your answer is considered correct if its absolute or relative error does not exceed 10^{-6}.

Formally, let your answer be a, and the jury's answer be b. Your answer is accepted if and only if \frac{|a - b|}{max{(1, |b|)}} ≤ 10^{-6}.

Examples

Input


4
3 -1 -1 1 2
2 3 -3 -2 10
-4 2 1 -2 1
-2 -2 -1 2 4


Output


0.585902082262898


Input


2
-1 1 -1 1 200
1 1 1 5 200


Output


No show :(

Note

Here is the picture for the first example: 

<image>

The fastest cars to crash are cars 2 and 4. Let's launch car 2 at 0, car 4 at about 0.096762 and cars 1 and 3 at arbitrary time. That way cars 2 and 4 will crash into each other at about 0.585902. So here's what it looks like at the moment of the collision:

<image>

Here's the picture for the second example:

<image>
#include <bits/stdc++.h>
using namespace std;
typedef long double Ti;
const long double PI = acos(-1), EPS = 1e-9;
int dcmp(long double x) { return abs(x) < EPS ? 0 : (x < 0 ? -1 : 1); }
struct Point {
  Ti x, y;
  Point(Ti x = 0, Ti y = 0) : x(x), y(y) {}
  Point operator+(const Point &u) const { return Point(x + u.x, y + u.y); }
  Point operator-(const Point &u) const { return Point(x - u.x, y - u.y); }
  Point operator*(const long long u) const { return Point(x * u, y * u); }
  Point operator*(const long double u) const { return Point(x * u, y * u); }
  Point operator/(const long double u) const { return Point(x / u, y / u); }
  bool operator==(const Point &u) const {
    return dcmp(x - u.x) == 0 && dcmp(y - u.y) == 0;
  }
  bool operator!=(const Point &u) const { return !(*this == u); }
  bool operator<(const Point &u) const {
    return dcmp(x - u.x) < 0 || (dcmp(x - u.x) == 0 && dcmp(y - u.y) < 0);
  }
  friend istream &operator>>(istream &is, Point &p) { return is >> p.x >> p.y; }
  friend ostream &operator<<(ostream &os, const Point &p) {
    return os << p.x << " " << p.y;
  }
};
Ti dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
Ti cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
long double length(Point a) { return sqrt(dot(a, a)); }
Ti sqLength(Point a) { return dot(a, a); }
long double distance(Point a, Point b) { return length(a - b); }
long double angle(Point u) { return atan2(u.y, u.x); }
long double angleBetween(Point a, Point b) {
  long double ans = angle(b) - angle(a);
  return ans <= -PI ? ans + 2 * PI : (ans > PI ? ans - 2 * PI : ans);
}
Point rotate(Point a, long double rad) {
  static_assert(is_same<long double, Ti>::value);
  return Point(a.x * cos(rad) - a.y * sin(rad),
               a.x * sin(rad) + a.y * cos(rad));
}
Point rotatePrecise(Point a, long double co, long double si) {
  static_assert(is_same<long double, Ti>::value);
  return Point(a.x * co - a.y * si, a.y * co + a.x * si);
}
Point rotate90(Point a) { return Point(-a.y, a.x); }
Point scale(Point a, long double s) {
  static_assert(is_same<long double, Ti>::value);
  return a / length(a) * s;
}
Point normal(Point a) {
  static_assert(is_same<long double, Ti>::value);
  long double l = length(a);
  return Point(-a.y / l, a.x / l);
}
int orient(Point a, Point b, Point c) { return dcmp(cross(b - a, c - a)); }
bool half(Point p) { return p.y > 0 || (p.y == 0 && p.x < 0); }
bool polarComp(Point p, Point q) {
  return make_tuple(half(p), 0) < make_tuple(half(q), cross(p, q));
}
struct Segment {
  Point a, b;
  Segment(Point aa, Point bb) : a(aa), b(bb) {}
};
struct Circle {
  Point o;
  long double r;
  Circle(Point o = Point(0, 0), long double r = 0) : o(o), r(r) {}
  bool contains(Point p) { return dcmp(sqLength(p - o) - r * r) <= 0; }
  Point point(long double rad) {
    static_assert(is_same<long double, Ti>::value);
    return Point(o.x + cos(rad) * r, o.y + sin(rad) * r);
  }
  long double area(long double rad = PI + PI) { return rad * r * r / 2; }
  long double sector(long double alpha) {
    return r * r * 0.5 * (alpha - sin(alpha));
  }
};
namespace Linear {
bool onSegment(Point p, Segment s) {
  return dcmp(cross(s.a - p, s.b - p)) == 0 && dcmp(dot(s.a - p, s.b - p)) <= 0;
}
bool segmentsIntersect(Segment p, Segment q) {
  if (onSegment(p.a, q) || onSegment(p.b, q)) return true;
  if (onSegment(q.a, p) || onSegment(q.b, p)) return true;
  Ti c1 = cross(p.b - p.a, q.a - p.a);
  Ti c2 = cross(p.b - p.a, q.b - p.a);
  Ti c3 = cross(q.b - q.a, p.a - q.a);
  Ti c4 = cross(q.b - q.a, p.b - q.a);
  return dcmp(c1) * dcmp(c2) < 0 && dcmp(c3) * dcmp(c4) < 0;
}
bool linesParallel(Segment p, Segment q) {
  return dcmp(cross(p.b - p.a, q.b - q.a)) == 0;
}
bool lineLineIntersection(Point p, Point v, Point q, Point w, Point &o) {
  static_assert(is_same<long double, Ti>::value);
  if (dcmp(cross(v, w)) == 0) return false;
  Point u = p - q;
  o = p + v * (cross(w, u) / cross(v, w));
  return true;
}
bool lineLineIntersection(Segment p, Segment q, Point &o) {
  return lineLineIntersection(p.a, p.b - p.a, q.a, q.b - q.a, o);
}
long double distancePointLine(Point p, Segment l) {
  return abs(cross(l.b - l.a, p - l.a) / length(l.b - l.a));
}
long double distancePointSegment(Point p, Segment s) {
  if (s.a == s.b) return length(p - s.a);
  Point v1 = s.b - s.a, v2 = p - s.a, v3 = p - s.b;
  if (dcmp(dot(v1, v2)) < 0)
    return length(v2);
  else if (dcmp(dot(v1, v3)) > 0)
    return length(v3);
  else
    return abs(cross(v1, v2) / length(v1));
}
long double distanceSegmentSegment(Segment p, Segment q) {
  if (segmentsIntersect(p, q)) return 0;
  long double ans = distancePointSegment(p.a, q);
  ans = min(ans, distancePointSegment(p.b, q));
  ans = min(ans, distancePointSegment(q.a, p));
  ans = min(ans, distancePointSegment(q.b, p));
  return ans;
}
Point projectPointLine(Point p, Segment l) {
  static_assert(is_same<long double, Ti>::value);
  Point v = l.b - l.a;
  return l.a + v * ((long double)dot(v, p - l.a) / dot(v, v));
}
}  // namespace Linear
namespace Polygonal {
vector<Point> RemoveCollinear(const vector<Point> &poly) {
  vector<Point> ret;
  int n = poly.size();
  for (int i = 0; i < n; i++) {
    Point a = poly[i];
    Point b = poly[(i + 1) % n];
    Point c = poly[(i + 2) % n];
    if (dcmp(cross(b - a, c - b)) != 0 && (ret.empty() || b != ret.back()))
      ret.push_back(b);
  }
  return ret;
}
long double signedPolygonArea(const vector<Point> &p) {
  long double ret = 0;
  for (int i = 0; i < (int)p.size() - 1; i++)
    ret += cross(p[i] - p[0], p[i + 1] - p[0]);
  return ret / 2;
}
vector<Point> convexHull(vector<Point> p, bool removeRedundant) {
  int check = removeRedundant ? 0 : -1;
  sort(p.begin(), p.end());
  p.erase(unique(p.begin(), p.end()), p.end());
  int n = p.size();
  vector<Point> ch(n + n);
  int m = 0;
  for (int i = 0; i < n; i++) {
    while (m > 1 &&
           dcmp(cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 1])) <= check)
      m--;
    ch[m++] = p[i];
  }
  int k = m;
  for (int i = n - 2; i >= 0; i--) {
    while (m > k &&
           dcmp(cross(ch[m - 1] - ch[m - 2], p[i] - ch[m - 2])) <= check)
      m--;
    ch[m++] = p[i];
  }
  if (n > 1) m--;
  ch.resize(m);
  return ch;
}
int pointInPolygon(const vector<Point> &p, Point o) {
  using Linear::onSegment;
  int wn = 0, n = p.size();
  for (int i = 0; i < n; i++) {
    int j = (i + 1) % n;
    if (onSegment(o, Segment(p[i], p[j])) || o == p[i]) return 0;
    int k = dcmp(cross(p[j] - p[i], o - p[i]));
    int d1 = dcmp(p[i].y - o.y);
    int d2 = dcmp(p[j].y - o.y);
    if (k > 0 && d1 <= 0 && d2 > 0) wn++;
    if (k < 0 && d2 <= 0 && d1 > 0) wn--;
  }
  return wn ? -1 : 1;
}
pair<long double, long double> linePolygonIntersection(Segment l,
                                                       const vector<Point> &p) {
  using Linear::lineLineIntersection;
  int n = p.size();
  vector<pair<long double, int>> ev;
  for (int i = 0; i < n; ++i) {
    Point a = p[i], b = p[(i + 1) % n], z = p[(i - 1 + n) % n];
    int ora = orient(l.a, l.b, a), orb = orient(l.a, l.b, b),
        orz = orient(l.a, l.b, z);
    if (!ora) {
      long double d = dot(a - l.a, l.b - l.a);
      if (orz && orb) {
        if (orz != orb) ev.emplace_back(d, 0);
      } else if (orz)
        ev.emplace_back(d, orz);
      else if (orb)
        ev.emplace_back(d, orb);
    } else if (ora == -orb) {
      Point ins;
      lineLineIntersection(l, Segment(a, b), ins);
      ev.emplace_back(dot(ins - l.a, l.b - l.a), 0);
    }
  }
  sort(ev.begin(), ev.end());
  long double ans = 0, len = 0, last = 0, tot = 0;
  bool active = false;
  int sign = 0;
  for (auto &qq : ev) {
    int tp = qq.second;
    long double d = qq.first;
    if (sign) {
      len += d - last;
      tot += d - last;
      ans = max(ans, len);
      if (tp != sign) active = !active;
      sign = 0;
    } else {
      if (active) {
        len += d - last;
        tot += d - last;
        ans = max(ans, len);
      }
      if (tp == 0)
        active = !active;
      else
        sign = tp;
    }
    last = d;
    if (!active) len = 0;
  }
  ans /= length(l.b - l.a);
  tot /= length(l.b - l.a);
  return {ans, tot};
}
}  // namespace Polygonal
namespace Convex {
void rotatingCalipersGetRectangle(Point *p, int n, long double &area,
                                  long double &perimeter) {
  using Linear::distancePointLine;
  static_assert(is_same<long double, Ti>::value);
  p[n] = p[0];
  int l = 1, r = 1, j = 1;
  area = perimeter = 1e100;
  for (int i = 0; i < n; i++) {
    Point v = (p[i + 1] - p[i]) / length(p[i + 1] - p[i]);
    while (dcmp(dot(v, p[r % n] - p[i]) - dot(v, p[(r + 1) % n] - p[i])) < 0)
      r++;
    while (j < r || dcmp(cross(v, p[j % n] - p[i]) -
                         cross(v, p[(j + 1) % n] - p[i])) < 0)
      j++;
    while (l < j ||
           dcmp(dot(v, p[l % n] - p[i]) - dot(v, p[(l + 1) % n] - p[i])) > 0)
      l++;
    long double w = dot(v, p[r % n] - p[i]) - dot(v, p[l % n] - p[i]);
    long double h = distancePointLine(p[j % n], Segment(p[i], p[i + 1]));
    area = min(area, w * h);
    perimeter = min(perimeter, 2 * w + 2 * h);
  }
}
vector<Point> cutPolygon(vector<Point> u, Point a, Point b) {
  using Linear::lineLineIntersection;
  using Linear::onSegment;
  vector<Point> ret;
  int n = u.size();
  for (int i = 0; i < n; i++) {
    Point c = u[i], d = u[(i + 1) % n];
    if (dcmp(cross(b - a, c - a)) >= 0) ret.push_back(c);
    if (dcmp(cross(b - a, d - c)) != 0) {
      Point t;
      lineLineIntersection(a, b - a, c, d - c, t);
      if (onSegment(t, Segment(c, d))) ret.push_back(t);
    }
  }
  return ret;
}
bool pointInTriangle(Point a, Point b, Point c, Point p) {
  return dcmp(cross(b - a, p - a)) >= 0 && dcmp(cross(c - b, p - b)) >= 0 &&
         dcmp(cross(a - c, p - c)) >= 0;
}
int pointInConvexPolygon(const vector<Point> &pt, Point p) {
  int n = pt.size();
  assert(n >= 3);
  int lo = 1, hi = n - 1;
  while (hi - lo > 1) {
    int mid = (lo + hi) / 2;
    if (dcmp(cross(pt[mid] - pt[0], p - pt[0])) > 0)
      lo = mid;
    else
      hi = mid;
  }
  bool in = pointInTriangle(pt[0], pt[lo], pt[hi], p);
  if (!in) return 1;
  if (dcmp(cross(pt[lo] - pt[lo - 1], p - pt[lo - 1])) == 0) return 0;
  if (dcmp(cross(pt[hi] - pt[lo], p - pt[lo])) == 0) return 0;
  if (dcmp(cross(pt[hi] - pt[(hi + 1) % n], p - pt[(hi + 1) % n])) == 0)
    return 0;
  return -1;
}
int extremePoint(const vector<Point> &poly, Point u = Point(0, 1)) {
  int n = (int)poly.size();
  int a = 0, b = n;
  while (b - a > 1) {
    int c = (a + b) / 2;
    if (dcmp(dot(poly[c] - poly[(c + 1) % n], u)) >= 0 &&
        dcmp(dot(poly[c] - poly[(c - 1 + n) % n], u)) >= 0) {
      return c;
    }
    bool a_up = dcmp(dot(poly[(a + 1) % n] - poly[a], u)) >= 0;
    bool c_up = dcmp(dot(poly[(c + 1) % n] - poly[c], u)) >= 0;
    bool a_above_c = dcmp(dot(poly[a] - poly[c], u)) > 0;
    if (a_up && !c_up)
      b = c;
    else if (!a_up && c_up)
      a = c;
    else if (a_up && c_up) {
      if (a_above_c)
        b = c;
      else
        a = c;
    } else {
      if (!a_above_c)
        b = c;
      else
        a = c;
    }
  }
  if (dcmp(dot(poly[a] - poly[(a + 1) % n], u)) > 0 &&
      dcmp(dot(poly[a] - poly[(a - 1 + n) % n], u)) > 0)
    return a;
  return b % n;
}
vector<int> lineConvexPolyIntersection(const vector<Point> &p, Segment l) {
  assert((int)p.size() >= 3);
  assert(l.a != l.b);
  int n = p.size();
  vector<int> ret;
  Point v = l.b - l.a;
  int lf = extremePoint(p, rotate90(v));
  int rt = extremePoint(p, rotate90(v) * Ti(-1));
  int olf = orient(l.a, l.b, p[lf]);
  int ort = orient(l.a, l.b, p[rt]);
  if (!olf || !ort) {
    int idx = (!olf ? lf : rt);
    if (orient(l.a, l.b, p[(idx - 1 + n) % n]) == 0)
      ret.push_back((idx - 1 + n) % n);
    else
      ret.push_back(idx);
    return ret;
  }
  if (olf == ort) return ret;
  for (int i = 0; i < 2; ++i) {
    int lo = i ? rt : lf;
    int hi = i ? lf : rt;
    int olo = i ? ort : olf;
    while (true) {
      int gap = (hi - lo + n) % n;
      if (gap < 2) break;
      int mid = (lo + gap / 2) % n;
      int omid = orient(l.a, l.b, p[mid]);
      if (!omid) {
        lo = mid;
        break;
      }
      if (omid == olo)
        lo = mid;
      else
        hi = mid;
    }
    ret.push_back(lo);
  }
  return ret;
}
constexpr int CW = -1, ACW = 1;
bool isGood(Point u, Point v, Point Q, int dir) {
  return orient(Q, u, v) != -dir;
}
Point better(Point u, Point v, Point Q, int dir) {
  return orient(Q, u, v) == dir ? u : v;
}
Point pointPolyTangent(const vector<Point> &pt, Point Q, int dir, int lo,
                       int hi) {
  while (hi - lo > 1) {
    int mid = (lo + hi) / 2;
    bool pvs = isGood(pt[mid], pt[mid - 1], Q, dir);
    bool nxt = isGood(pt[mid], pt[mid + 1], Q, dir);
    if (pvs && nxt) return pt[mid];
    if (!(pvs || nxt)) {
      Point p1 = pointPolyTangent(pt, Q, dir, mid + 1, hi);
      Point p2 = pointPolyTangent(pt, Q, dir, lo, mid - 1);
      return better(p1, p2, Q, dir);
    }
    if (!pvs) {
      if (orient(Q, pt[mid], pt[lo]) == dir)
        hi = mid - 1;
      else if (better(pt[lo], pt[hi], Q, dir) == pt[lo])
        hi = mid - 1;
      else
        lo = mid + 1;
    }
    if (!nxt) {
      if (orient(Q, pt[mid], pt[lo]) == dir)
        lo = mid + 1;
      else if (better(pt[lo], pt[hi], Q, dir) == pt[lo])
        hi = mid - 1;
      else
        lo = mid + 1;
    }
  }
  Point ret = pt[lo];
  for (int i = lo + 1; i <= hi; i++) ret = better(ret, pt[i], Q, dir);
  return ret;
}
pair<Point, Point> pointPolyTangents(const vector<Point> &pt, Point Q) {
  int n = pt.size();
  Point acw_tan = pointPolyTangent(pt, Q, ACW, 0, n - 1);
  Point cw_tan = pointPolyTangent(pt, Q, CW, 0, n - 1);
  return make_pair(acw_tan, cw_tan);
}
}  // namespace Convex
namespace Circular {
vector<Point> circleLineIntersection(Circle c, Segment l) {
  static_assert(is_same<long double, Ti>::value);
  vector<Point> ret;
  Point b = l.b - l.a, a = l.a - c.o;
  long double A = dot(b, b), B = dot(a, b);
  long double C = dot(a, a) - c.r * c.r, D = B * B - A * C;
  if (D < -EPS) return ret;
  ret.push_back(l.a + b * (-B - sqrt(D + EPS)) / A);
  if (D > EPS) ret.push_back(l.a + b * (-B + sqrt(D)) / A);
  return ret;
}
long double circleTriangleIntersectionArea(Circle c, Segment s) {
  using Linear::distancePointSegment;
  long double OA = length(c.o - s.a);
  long double OB = length(c.o - s.b);
  if (dcmp(distancePointSegment(c.o, s) - c.r) >= 0)
    return angleBetween(s.a - c.o, s.b - c.o) * (c.r * c.r) / 2.0;
  if (dcmp(OA - c.r) <= 0 && dcmp(OB - c.r) <= 0)
    return cross(c.o - s.b, s.a - s.b) / 2.0;
  vector<Point> Sect = circleLineIntersection(c, s);
  return circleTriangleIntersectionArea(c, Segment(s.a, Sect[0])) +
         circleTriangleIntersectionArea(c, Segment(Sect[0], Sect[1])) +
         circleTriangleIntersectionArea(c, Segment(Sect[1], s.b));
}
long double circlePolyIntersectionArea(Circle c, vector<Point> p) {
  long double res = 0;
  int n = p.size();
  for (int i = 0; i < n; ++i)
    res += circleTriangleIntersectionArea(c, Segment(p[i], p[(i + 1) % n]));
  return abs(res);
}
int circleCirclePosition(Circle c1, Circle c2) {
  long double d = length(c1.o - c2.o);
  int in = dcmp(d - abs(c1.r - c2.r)), ex = dcmp(d - (c1.r + c2.r));
  return in < 0 ? -2 : in == 0 ? -1 : ex == 0 ? 1 : ex > 0 ? 2 : 0;
}
vector<Point> circleCircleIntersection(Circle c1, Circle c2) {
  static_assert(is_same<long double, Ti>::value);
  vector<Point> ret;
  long double d = length(c1.o - c2.o);
  if (dcmp(d) == 0) return ret;
  if (dcmp(c1.r + c2.r - d) < 0) return ret;
  if (dcmp(abs(c1.r - c2.r) - d) > 0) return ret;
  Point v = c2.o - c1.o;
  long double co =
      (c1.r * c1.r + sqLength(v) - c2.r * c2.r) / (2 * c1.r * length(v));
  long double si = sqrt(abs(1.0 - co * co));
  Point p1 = scale(rotatePrecise(v, co, -si), c1.r) + c1.o;
  Point p2 = scale(rotatePrecise(v, co, si), c1.r) + c1.o;
  ret.push_back(p1);
  if (p1 != p2) ret.push_back(p2);
  return ret;
}
long double circleCircleIntersectionArea(Circle c1, Circle c2) {
  Point AB = c2.o - c1.o;
  long double d = length(AB);
  if (d >= c1.r + c2.r) return 0;
  if (d + c1.r <= c2.r) return PI * c1.r * c1.r;
  if (d + c2.r <= c1.r) return PI * c2.r * c2.r;
  long double alpha1 =
      acos((c1.r * c1.r + d * d - c2.r * c2.r) / (2.0 * c1.r * d));
  long double alpha2 =
      acos((c2.r * c2.r + d * d - c1.r * c1.r) / (2.0 * c2.r * d));
  return c1.sector(2 * alpha1) + c2.sector(2 * alpha2);
}
vector<Point> pointCircleTangents(Point p, Circle c) {
  static_assert(is_same<long double, Ti>::value);
  vector<Point> ret;
  Point u = c.o - p;
  long double d = length(u);
  if (d < c.r)
    ;
  else if (dcmp(d - c.r) == 0) {
    ret = {rotate(u, PI / 2)};
  } else {
    long double ang = asin(c.r / d);
    ret = {rotate(u, -ang), rotate(u, ang)};
  }
  return ret;
}
vector<Point> pointCircleTangencyPoints(Point p, Circle c) {
  static_assert(is_same<long double, Ti>::value);
  Point u = p - c.o;
  long double d = length(u);
  if (d < c.r)
    return {};
  else if (dcmp(d - c.r) == 0)
    return {c.o + u};
  else {
    long double ang = acos(c.r / d);
    u = u / length(u) * c.r;
    return {c.o + rotate(u, -ang), c.o + rotate(u, ang)};
  }
}
int circleCircleTangencyPoints(Circle c1, Circle c2, vector<Point> &a,
                               vector<Point> &b) {
  a.clear(), b.clear();
  int cnt = 0;
  if (dcmp(c1.r - c2.r) < 0) {
    swap(c1, c2);
    swap(a, b);
  }
  long double d2 = sqLength(c1.o - c2.o);
  long double rdif = c1.r - c2.r, rsum = c1.r + c2.r;
  if (dcmp(d2 - rdif * rdif) < 0) return 0;
  if (dcmp(d2) == 0 && dcmp(c1.r - c2.r) == 0) return -1;
  long double base = angle(c2.o - c1.o);
  if (dcmp(d2 - rdif * rdif) == 0) {
    a.push_back(c1.point(base));
    b.push_back(c2.point(base));
    cnt++;
    return cnt;
  }
  long double ang = acos((c1.r - c2.r) / sqrt(d2));
  a.push_back(c1.point(base + ang));
  b.push_back(c2.point(base + ang));
  cnt++;
  a.push_back(c1.point(base - ang));
  b.push_back(c2.point(base - ang));
  cnt++;
  if (dcmp(d2 - rsum * rsum) == 0) {
    a.push_back(c1.point(base));
    b.push_back(c2.point(PI + base));
    cnt++;
  } else if (dcmp(d2 - rsum * rsum) > 0) {
    long double ang = acos((c1.r + c2.r) / sqrt(d2));
    a.push_back(c1.point(base + ang));
    b.push_back(c2.point(PI + base + ang));
    cnt++;
    a.push_back(c1.point(base - ang));
    b.push_back(c2.point(PI + base - ang));
    cnt++;
  }
  return cnt;
}
}  // namespace Circular
namespace EnclosingCircle {
bool inscribedCircle(Point a, Point b, Point c, Circle &p) {
  using Linear::distancePointLine;
  static_assert(is_same<long double, Ti>::value);
  if (orient(a, b, c) == 0) return false;
  long double u = length(b - c);
  long double v = length(c - a);
  long double w = length(a - b);
  p.o = (a * u + b * v + c * w) / (u + v + w);
  p.r = distancePointLine(p.o, Segment(a, b));
  return true;
}
Circle apolloniusCircle(Point P, Point Q, long double rp, long double rq) {
  static_assert(is_same<long double, Ti>::value);
  rq *= rq;
  rp *= rp;
  long double a = rq - rp;
  assert(dcmp(a));
  long double g = (rq * P.x - rp * Q.x) / a;
  long double h = (rq * P.y - rp * Q.y) / a;
  long double c =
      (rq * P.x * P.x - rp * Q.x * Q.x + rq * P.y * P.y - rp * Q.y * Q.y) / a;
  Point o(g, h);
  long double R = sqrt(g * g + h * h - c);
  return Circle(o, R);
}
bool circumscribedCircle(Point a, Point b, Point c, Circle &p) {
  using Linear::lineLineIntersection;
  if (orient(a, b, c) == 0) return false;
  Point d = (a + b) / 2, e = (a + c) / 2;
  Point vd = rotate90(b - a), ve = rotate90(a - c);
  bool f = lineLineIntersection(d, vd, e, ve, p.o);
  if (f) p.r = length(a - p.o);
  return f;
}
Circle boundary(const vector<Point> &p) {
  Circle ret;
  int sz = p.size();
  if (sz == 0)
    ret.r = 0;
  else if (sz == 1)
    ret.o = p[0], ret.r = 0;
  else if (sz == 2)
    ret.o = (p[0] + p[1]) / 2, ret.r = length(p[0] - p[1]) / 2;
  else if (!circumscribedCircle(p[0], p[1], p[2], ret))
    ret.r = 0;
  return ret;
}
Circle welzl(const vector<Point> &p, int fr, vector<Point> &b) {
  if (fr >= (int)p.size() || b.size() == 3) return boundary(b);
  Circle c = welzl(p, fr + 1, b);
  if (!c.contains(p[fr])) {
    b.push_back(p[fr]);
    c = welzl(p, fr + 1, b);
    b.pop_back();
  }
  return c;
}
Circle minidisk(vector<Point> p) {
  random_shuffle(p.begin(), p.end());
  vector<Point> q;
  return welzl(p, 0, q);
}
}  // namespace EnclosingCircle
namespace IntersectingSegments {
struct Event {
  long double x;
  int tp, id;
  bool operator<(const Event &p) const {
    if (dcmp(x - p.x)) return x < p.x;
    return tp > p.tp;
  }
};
pair<int, int> anyIntersection(const vector<Segment> &v) {
  using Linear::segmentsIntersect;
  static_assert(is_same<long double, Ti>::value);
  vector<Event> ev;
  for (int i = 0; i < v.size(); i++) {
    ev.push_back({min(v[i].a.x, v[i].b.x), +1, i});
    ev.push_back({max(v[i].a.x, v[i].b.x), -1, i});
  }
  sort(ev.begin(), ev.end());
  auto comp = [&v](int i, int j) {
    Segment p = v[i], q = v[j];
    long double x = max(min(p.a.x, p.b.x), min(q.a.x, q.b.x));
    auto yvalSegment = [&x](const Segment &s) {
      if (dcmp(s.a.x - s.b.x) == 0) return s.a.y;
      return s.a.y + (s.b.y - s.a.y) * (x - s.a.x) / (s.b.x - s.a.x);
    };
    return dcmp(yvalSegment(p) - yvalSegment(q)) < 0;
  };
  multiset<int, decltype(comp)> st(comp);
  typedef decltype(st)::iterator iter;
  auto prev = [&st](iter it) { return it == st.begin() ? st.end() : --it; };
  auto next = [&st](iter it) { return it == st.end() ? st.end() : ++it; };
  vector<iter> pos(v.size());
  for (auto &cur : ev) {
    int id = cur.id;
    if (cur.tp == 1) {
      iter nxt = st.lower_bound(id);
      iter pre = prev(nxt);
      if (pre != st.end() && segmentsIntersect(v[*pre], v[id]))
        return {*pre, id};
      if (nxt != st.end() && segmentsIntersect(v[*nxt], v[id]))
        return {*nxt, id};
      pos[id] = st.insert(nxt, id);
    } else {
      iter nxt = next(pos[id]);
      iter pre = prev(pos[id]);
      if (pre != st.end() && nxt != st.end() &&
          segmentsIntersect(v[*pre], v[*nxt]))
        return {*pre, *nxt};
      st.erase(pos[id]);
    }
  }
  return {-1, -1};
}
}  // namespace IntersectingSegments
namespace Voronoi {
using Linear::lineLineIntersection;
struct DirLine {
  Point p, v;
  long double ang;
  DirLine() {}
  DirLine(Point p, Point v) : p(p), v(v) { ang = atan2(v.y, v.x); }
  bool operator<(const DirLine &u) const { return ang < u.ang; }
};
bool onLeft(DirLine l, Point p) { return dcmp(cross(l.v, p - l.p)) >= 0; }
int halfPlaneIntersection(vector<DirLine> &li, vector<Point> &poly) {
  int n = li.size();
  sort(li.begin(), li.end());
  int first, last;
  Point *p = new Point[n];
  DirLine *q = new DirLine[n];
  q[first = last = 0] = li[0];
  for (int i = 1; i < n; i++) {
    while (first < last && !onLeft(li[i], p[last - 1])) last--;
    while (first < last && !onLeft(li[i], p[first])) first++;
    q[++last] = li[i];
    if (dcmp(cross(q[last].v, q[last - 1].v)) == 0) {
      last--;
      if (onLeft(q[last], li[i].p)) q[last] = li[i];
    }
    if (first < last)
      lineLineIntersection(q[last - 1].p, q[last - 1].v, q[last].p, q[last].v,
                           p[last - 1]);
  }
  while (first < last && !onLeft(q[first], p[last - 1])) last--;
  if (last - first <= 1) {
    delete[] p;
    delete[] q;
    poly.clear();
    return 0;
  }
  lineLineIntersection(q[last].p, q[last].v, q[first].p, q[first].v, p[last]);
  int m = 0;
  poly.resize(last - first + 1);
  for (int i = first; i <= last; i++) poly[m++] = p[i];
  delete[] p;
  delete[] q;
  return m;
}
const long double INF = 1e10;
void voronoi(const vector<Point> &site, vector<vector<Point>> &region,
             long double bsq) {
  int n = site.size();
  region.resize(n);
  Point A(-bsq, -bsq), B(bsq, -bsq), C(bsq, bsq), D(-bsq, bsq);
  for (int i = 0; i < n; ++i) {
    vector<DirLine> li(n - 1);
    for (int j = 0, k = 0; j < n; ++j) {
      if (i == j) continue;
      li[k++] = DirLine((site[i] + site[j]) / 2, rotate90(site[j] - site[i]));
    }
    li.emplace_back(A, B - A);
    li.emplace_back(B, C - B);
    li.emplace_back(C, D - C);
    li.emplace_back(D, A - D);
    halfPlaneIntersection(li, region[i]);
  }
}
}  // namespace Voronoi
void solve_Timus_1185_Wall() {
  int N, L;
  cin >> N >> L;
  vector<Point> poly(N);
  for (Point &p : poly) cin >> p;
  vector<Point> ch = Polygonal::convexHull(poly, true);
  ch.push_back(ch.front());
  long double ans = 2 * PI * L;
  for (int i = 0; i + 1 < ch.size(); i++) {
    ans += distance(ch[i], ch[i + 1]);
  }
  int rounded = round(ans);
  cout << rounded << "\n";
}
void solve_CodeChef_CONTAIN() {
  int t;
  cin >> t;
  while (t--) {
    int n, q;
    cin >> n >> q;
    vector<Point> poly(n);
    for (Point &p : poly) cin >> p;
    set<Point> st(poly.begin(), poly.end());
    vector<vector<Point>> layers;
    while (!st.empty()) {
      poly = vector<Point>(st.begin(), st.end());
      layers.push_back(Polygonal::convexHull(poly, false));
      for (Point p : layers.back()) st.erase(p);
      if (layers.back().size() < 3) layers.pop_back();
    }
    while (q--) {
      Point p;
      cin >> p;
      int ans = 0;
      for (int i = 0; i < layers.size(); i++) {
        if (Convex::pointInConvexPolygon(layers[i], p) >= 0) break;
        ans++;
      }
      cout << ans << "\n";
    }
  }
}
void solve_SPOJ_INOROUT() {
  int n, q;
  cin >> n >> q;
  vector<Point> poly(n);
  for (Point &p : poly) cin >> p;
  poly = Polygonal::RemoveCollinear(poly);
  while (q--) {
    Point p;
    cin >> p;
    int g = Convex::pointInConvexPolygon(poly, p);
    if (g <= 0)
      cout << 'D' << '\n';
    else
      cout << 'F' << '\n';
  }
}
void solve_SPOJ_INOROUT_Alternate() {
  int n, q;
  cin >> n >> q;
  vector<Point> poly(n);
  for (Point &p : poly) cin >> p;
  while (q--) {
    Point p;
    cin >> p;
    int g = Polygonal::pointInPolygon(poly, p);
    if (g <= 0)
      cout << 'D' << '\n';
    else
      cout << 'F' << '\n';
  }
}
void solveTimus1955() {
  int n;
  cin >> n;
  vector<Point> p(n);
  for (int i = 0; i < n; i++) {
    cin >> p[i].x >> p[i].y;
  }
  long double ans = 0;
  for (int i = 0; i < n; i++)
    for (int j = i + 1; j < n; j++)
      ans =
          max(ans,
              Polygonal::linePolygonIntersection(Segment(p[i], p[j]), p).first);
  cout << setprecision(10) << fixed << ans << endl;
}
void solveLittleMammoth() {
  using namespace Circular;
  freopen("mammoth.in", "r", stdin);
  freopen("mammoth.out", "w", stdout);
  Point O;
  long double r;
  cin >> O.x >> O.y >> r;
  Point A, C;
  cin >> A.x >> A.y >> C.x >> C.y;
  Point B(A.x, C.y), D(C.x, A.y);
  cout << setprecision(10) << fixed
       << circlePolyIntersectionArea(Circle(O, r), {A, B, C, D});
}
void solveCodeforces598F_CutLength() {
  int n, q;
  cin >> n >> q;
  vector<Point> p(n);
  for (int i = 0; i < n; i++) {
    cin >> p[i].x >> p[i].y;
  }
  while (q--) {
    Point P, Q;
    cin >> P.x >> P.y >> Q.x >> Q.y;
    cout << setprecision(10) << fixed
         << Polygonal::linePolygonIntersection(Segment(P, Q), p).second << endl;
  }
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int n;
  cin >> n;
  vector<Point> p(n), v(n);
  vector<long double> s(n);
  for (int i = 0; i < n; i++) cin >> p[i] >> v[i] >> s[i];
  bool found = false;
  long double lo = 0, hi = 1e10;
  for (int it = 0; it < 60; it++) {
    long double m = (lo + hi) / 2;
    vector<Segment> ss;
    for (int i = 0; i < n; i++) {
      Point A = p[i], B = p[i] + v[i] / length(v[i]) * s[i] * m;
      ss.push_back(Segment(A, B));
    }
    if (IntersectingSegments::anyIntersection(ss).first != -1)
      found = true, hi = m;
    else
      lo = m;
  }
  if (!found)
    cout << "No show :(" << endl;
  else
    cout << setprecision(15) << fixed << lo << endl;
}
