#include <bits/stdc++.h>
#pragma GCC optimize("Ofast", "unroll-loops", "omit-frame-pointer", "inline")
#pragma GCC option("arch=native", "tune=native", "no-zero-upper")
#pragma GCC target("avx2")
using namespace std;
template <typename T>
void maxtt(T &t1, T t2) {
  t1 = max(t1, t2);
}
template <typename T>
void mintt(T &t1, T t2) {
  t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
string direc = "RDLU";
const long long MOD2 = (long long)998244353 * (long long)998244353;
long long ln, lk, lm;
void etp(bool f = 0) {
  puts(f ? "YES" : "NO");
  exit(0);
}
void addmod(int &x, int y, int mod = 998244353) {
  x += y;
  if (x >= mod) x -= mod;
  if (x < 0) x += mod;
  assert(x >= 0 && x < mod);
}
void et(int x = -1) {
  printf("%d\n", x);
  exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
  long long ans = 1;
  while (y > 0) {
    if (y & 1) ans = (x * ans) % mod;
    x = x * x % mod;
    y >>= 1;
  }
  return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int sign(long double k) {
  if (k > 1e-9)
    return 1;
  else if (k < -1e-9)
    return -1;
  return 0;
}
struct Point {
  long double x, y;
  Point() {}
  Point(long double x, long double y) : x(x), y(y) {}
  long double abs() const { return hypot(x, y); }
  long double arg() const { return atan2(y, x); }
  Point operator*(double o) const { return Point(x * o, y * o); }
  Point operator+(const Point &o) const { return Point(x + o.x, y + o.y); }
  Point operator-(const Point &o) const { return Point(x - o.x, y - o.y); }
  Point operator/(double o) const { return Point(x / o, y / o); }
  bool operator<(const Point &o) const {
    return x < o.x - 1e-9 || (x < o.x + 1e-9 && y < o.y - 1e-9);
  }
  friend bool operator==(const Point &r1, const Point &r2) {
    return r1.x == r2.x && r1.y == r2.y;
  }
  Point scale(double o) const { return *this * (o / abs()); }
  Point rotY() const { return Point(-y, x); }
  Point rotX() const { return Point(y, -x); }
  long double cross(Point b) const { return x * b.y - b.x * y; }
  long double dot(Point b) const { return x * b.x + y * b.y; }
  long double disToSeg(Point &a, Point &b) {
    return fabs(((*this) - a).cross(b - a) / (b - a).abs());
  }
  pair<long long, long long> getVec() {
    if (x == 0) return {0, y > 0 ? 1 : -1};
    if (y == 0) return {x < 0 ? -1 : 1, 0};
    long long gg = gcd1(::abs(x), ::abs(y));
    long long px = x / gg, py = y / gg;
    return {px, py};
  }
  void readin() { scanf("%lf%lf", &x, &y); }
};
struct Line {
  Point s, t;
  int id;
  Line() {}
  Line(Point p, Point q) {
    s = p;
    t = q;
  }
  long double get_y(long double x) const {
    if (sign(s.x - t.x) == 0) return s.y;
    return s.y + (t.y - s.y) * (x - s.x) / (t.x - s.x);
  }
};
int cmp(long double k1, long double k2) { return sign(k1 - k2); }
int intersect(long double l1, long double r1, long double l2, long double r2) {
  if (l1 > r1) swap(l1, r1);
  if (l2 > r2) swap(l2, r2);
  return cmp(r1, l2) != -1 && cmp(r2, l1) != -1;
}
int checkSS(Point k1, Point k2, Point k3, Point k4) {
  return intersect(k1.x, k2.x, k3.x, k4.x) &&
         intersect(k1.y, k2.y, k3.y, k4.y) &&
         sign((k3 - k1).cross(k4 - k1)) * sign((k3 - k2).cross(k4 - k2)) <= 0 &&
         sign((k1 - k3).cross(k2 - k3)) * sign((k1 - k4).cross(k2 - k4)) <= 0;
}
int intersect(Line a, Line b) { return checkSS(a.s, a.t, b.s, b.t); }
bool operator<(const Line &a, const Line &b) {
  long double x = max(min(a.s.x, a.t.x), min(b.s.x, b.t.x));
  return sign(a.get_y(x) - b.get_y(x)) <= 0;
}
struct has_inter {
  struct event {
    long double x;
    int tp, id;
    event() {}
    event(long double x, int tp, int id) : x(x), tp(tp), id(id) {}
    bool operator<(const event &e) const {
      if (sign(x - e.x) == 0) return tp > e.tp;
      return sign(x - e.x) < 0;
    }
  };
  set<Line> s;
  vector<set<Line>::iterator> where;
  inline set<Line>::iterator prev(set<Line>::iterator it) {
    return it == s.begin() ? s.end() : --it;
  }
  inline set<Line>::iterator next(set<Line>::iterator it) { return ++it; }
  pair<int, int> solve(vector<Line> &a) {
    int n = a.size();
    vector<event> e;
    for (int i = 0; i < n; i++) {
      e.push_back(event(min(a[i].s.x, a[i].t.x), +1, i));
      e.push_back(event(max(a[i].s.x, a[i].t.x), -1, i));
    }
    sort(e.begin(), e.end());
    s.clear();
    where.resize(a.size());
    for (int i = 0; i < e.size(); i++) {
      int id = e[i].id;
      if (e[i].tp == +1) {
        auto nxt = s.lower_bound(a[id]);
        auto prv = prev(nxt);
        if (nxt != s.end() && intersect(*nxt, a[id]))
          return make_pair(nxt->id, id);
        if (prv != s.end() && intersect(*prv, a[id]))
          return make_pair(prv->id, id);
        where[id] = s.insert(nxt, a[id]);
      } else {
        if (where[id] == s.end()) continue;
        auto nxt = next(where[id]), prv = prev(where[id]);
        if (nxt != s.end() && prv != s.end() && intersect(*nxt, *prv))
          return make_pair(prv->id, nxt->id);
        s.erase(where[id]);
      }
    }
    return make_pair(-1, -1);
  }
};
int x[25135], y[25135], dx[25135], dy[25135], s[25135];
bool ck(long double t) {
  vector<Line> vp;
  for (int(i) = 1; (i) <= (int)(n); (i)++) {
    long double d = sqrt(dx[i] * dx[i] + dy[i] * dy[i]);
    Point k1 = Point(x[i], y[i]);
    Point k2 = Point(x[i] + t * s[i] * dx[i] / d, y[i] + t * s[i] * dy[i] / d);
    Line l = {k1, k2};
    l.id = i;
    vp.push_back(l);
  }
  has_inter Q;
  return Q.solve(vp).first != -1;
}
void fmain(int tid) {
  scanf("%d", &n);
  for (int(i) = 1; (i) <= (int)(n); (i)++)
    scanf("%d%d%d%d%d", x + i, y + i, dx + i, dy + i, s + i);
  long double l = 0, r = 1e10;
  bool ok = 0;
  for (int(i) = 0; (i) < (int)(100); (i)++) {
    long double mid = (l + r) / 2;
    if (ck(mid)) {
      ok = 1;
      r = mid;
    } else
      l = mid;
  }
  if (!ok)
    puts("No show :(");
  else
    printf("%.10Lf\n", l);
}
int main() {
  int t = 1;
  for (int(i) = 1; (i) <= (int)(t); (i)++) {
    fmain(i);
  }
  return 0;
}
