#include <bits/stdc++.h>
using namespace std;
constexpr long long mod = 1000000007;
const long long INF = mod * mod;
const long double eps = 1e-12;
const long double pi = acos(-1.0);
void chmin(int &a, int b) { a = min(a, b); }
void chmax(int &a, int b) { a = max(a, b); }
long long mod_pow(long long a, long long n, long long m = mod) {
  a %= m;
  long long res = 1;
  while (n) {
    if (n & 1) res = res * a % m;
    a = a * a % m;
    n >>= 1;
  }
  return res;
}
struct modint {
  long long n;
  modint() : n(0) { ; }
  modint(long long m) : n(m) {
    if (n >= mod)
      n %= mod;
    else if (n < 0)
      n = (n % mod + mod) % mod;
  }
  operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) {
  a.n += b.n;
  if (a.n >= mod) a.n -= mod;
  return a;
}
modint operator-=(modint &a, modint b) {
  a.n -= b.n;
  if (a.n < 0) a.n += mod;
  return a;
}
modint operator*=(modint &a, modint b) {
  a.n = ((long long)a.n * b.n) % mod;
  return a;
}
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
  if (n == 0) return modint(1);
  modint res = (a * a) ^ (n / 2);
  if (n % 2) res = res * a;
  return res;
}
long long inv(long long a, long long p) {
  return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 10001000;
modint fact[max_n], factinv[max_n];
void init_f() {
  fact[0] = modint(1);
  for (int i = 0; i < max_n - 1; i++) {
    fact[i + 1] = fact[i] * modint(i + 1);
  }
  factinv[max_n - 1] = modint(1) / fact[max_n - 1];
  for (int i = max_n - 2; i >= 0; i--) {
    factinv[i] = factinv[i + 1] * modint(i + 1);
  }
}
modint comb(int a, int b) {
  if (a < 0 || b < 0 || a < b) return 0;
  return fact[a] * factinv[b] * factinv[a - b];
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
struct Point {
  long double x, y;
};
struct Line {
  Point a, b;
};
bool intersect1d(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 max(l1, l2) <= min(r1, r2) + eps;
}
int vec(const Point &a, const Point &b, const Point &c) {
  long double s = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
  return abs(s) < eps ? 0 : s > 0 ? +1 : -1;
}
bool intersect(const Line &a, const Line &b) {
  return intersect1d(a.a.x, a.b.x, b.a.x, b.b.x) &&
         intersect1d(a.a.y, a.b.y, b.a.y, b.b.y) &&
         vec(a.a, a.b, b.a) * vec(a.a, a.b, b.b) <= 0 &&
         vec(b.a, b.b, a.a) * vec(b.a, b.b, a.b) <= 0;
}
struct eve {
  long double x;
  int tp, id;
  eve() {}
  eve(long double x, int tp, int id) : x(x), tp(tp), id(id) {}
  bool operator<(const eve &e) const {
    if (abs(x - e.x) > eps) return x < e.x;
    return tp > e.tp;
  }
};
set<Line> s;
vector<set<Line>::iterator> itrs;
set<Line>::iterator aprev(set<Line>::iterator it) {
  return it == s.begin() ? s.end() : --it;
}
set<Line>::iterator anext(set<Line>::iterator it) { return ++it; }
long double get_y(const Line &l, long double x) {
  if (abs(l.a.x - l.b.x) < eps) return l.a.y;
  return l.a.y + (l.b.y - l.a.y) * (x - l.a.x) / (l.b.x - l.a.x);
}
bool operator<(const Line &a, const Line &b) {
  long double x = max(min(a.a.x, a.b.x), min(b.a.x, b.b.x));
  return get_y(a, x) < get_y(b, x);
}
bool exist_intersect(vector<Line> &a) {
  int n = a.size();
  vector<eve> e;
  for (int i = 0; i < n; i++) {
    e.push_back(eve{min(a[i].a.x, a[i].b.x), 1, i});
    e.push_back(eve{max(a[i].a.x, a[i].b.x), -1, i});
  }
  sort((e).begin(), (e).end());
  s.clear();
  itrs.resize(n);
  for (int i = 0; i < e.size(); i++) {
    int id = e[i].id;
    if (e[i].tp > 0) {
      auto nxt = s.lower_bound(a[id]), prv = aprev(nxt);
      if (nxt != s.end() && intersect(*nxt, a[id])) return true;
      if (prv != s.end() && intersect(*prv, a[id])) return true;
      itrs[id] = s.insert(nxt, a[id]);
    } else {
      auto nxt = anext(itrs[id]), prv = aprev(itrs[id]);
      if (nxt != s.end() && prv != s.end() && intersect(*nxt, *prv)) {
        return true;
      }
      s.erase(itrs[id]);
    }
  }
  return false;
}
void solve() {
  int n;
  cin >> n;
  vector<long double> x(n), y(n), vx(n), vy(n), s(n);
  for (int i = 0; i < n; i++) {
    cin >> x[i] >> y[i] >> vx[i] >> vy[i] >> s[i];
    long double r = sqrtl(vx[i] * vx[i] + vy[i] * vy[i]);
    vx[i] *= s[i] / r;
    vy[i] *= s[i] / r;
  }
  long double le = 0, ri = 1e+10;
  bool exi = false;
  for (int aa = 0; aa < 60; aa++) {
    long double m = (le + ri) / 2.0;
    vector<Line> vl;
    for (int i = 0; i < n; i++) {
      Point pl = {x[i], y[i]};
      Point pr = {x[i] + vx[i] * m, y[i] + vy[i] * m};
      vl.push_back({pl, pr});
    }
    if (exist_intersect(vl)) {
      exi = true;
      ri = m;
    } else {
      le = m;
    }
  }
  if (!exi) {
    cout << "No show :("
         << "\n";
  } else {
    cout << ri << "\n";
  }
}
signed main() {
  cout << fixed << setprecision(7);
  solve();
  char nyaa;
  cin >> nyaa;
  return 0;
}
