#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 100001;
const long double EPS = 1E-12;
struct pt {
  long double x, y;
};
struct seg {
  pt p, q;
  int id;
  long double get_y(long double x) const {
    if (abs(p.x - q.x) < EPS) return p.y;
    return p.y + (q.y - p.y) * (x - p.x) / (q.x - p.x);
  }
};
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 pt& a, const pt& b, const pt& c) {
  long double second = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
  return abs(second) < EPS ? 0 : second > 0 ? +1 : -1;
}
bool intersect(const seg& a, const seg& b) {
  return intersect1d(a.p.x, a.q.x, b.p.x, b.q.x) &&
         intersect1d(a.p.y, a.q.y, b.p.y, b.q.y) &&
         vec(a.p, a.q, b.p) * vec(a.p, a.q, b.q) <= 0 &&
         vec(b.p, b.q, a.p) * vec(b.p, b.q, a.q) <= 0;
}
bool operator<(const seg& a, const seg& b) {
  long double x = max(min(a.p.x, a.q.x), min(b.p.x, b.q.x));
  if (a.get_y(x) + EPS < b.get_y(x)) {
    return true;
  } else if (b.get_y(x) + EPS < a.get_y(x)) {
    return false;
  }
  return a.id < b.id;
}
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 (abs(x - e.x) > EPS) return x < e.x;
    return tp > e.tp;
  }
};
set<seg> second;
vector<set<seg>::iterator> where;
set<seg>::iterator prev(set<seg>::iterator it) {
  return it == second.begin() ? second.end() : --it;
}
set<seg>::iterator next(set<seg>::iterator it) { return ++it; }
pair<int, int> solve(const vector<seg>& a) {
  int n = (int)a.size();
  vector<event> e;
  for (int i = 0; i < n; ++i) {
    e.push_back(event(min(a[i].p.x, a[i].q.x), +1, i));
    e.push_back(event(max(a[i].p.x, a[i].q.x), -1, i));
  }
  sort(e.begin(), e.end());
  second.clear();
  where.resize(a.size());
  for (size_t i = 0; i < e.size(); ++i) {
    int id = e[i].id;
    if (e[i].tp == +1) {
      set<seg>::iterator nxt = second.lower_bound(a[id]), prv = prev(nxt);
      if (nxt != second.end() && intersect(*nxt, a[id]))
        return make_pair(nxt->id, id);
      if (prv != second.end() && intersect(*prv, a[id]))
        return make_pair(prv->id, id);
      where[id] = second.insert(nxt, a[id]);
    } else {
      set<seg>::iterator nxt = next(where[id]), prv = prev(where[id]);
      if (nxt != second.end() && prv != second.end() && intersect(*nxt, *prv))
        return make_pair(prv->id, nxt->id);
      second.erase(where[id]);
    }
  }
  return make_pair(-1, -1);
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int N;
  cin >> N;
  vector<pt> points;
  long double dx[N], dy[N];
  for (int i = 0; i < (N); i++) {
    long double X, Y;
    cin >> X >> Y;
    points.push_back({X, Y});
    long double A, B, C;
    cin >> A >> B >> C;
    long double M = sqrt(A * A + B * B);
    if (M < 0.5) {
      dx[i] = 0;
      dy[i] = 0;
      continue;
    }
    A /= M;
    B /= M;
    A *= C;
    B *= C;
    dx[i] = A;
    dy[i] = B;
  }
  long double lo = 0;
  long double hi = 1e16;
  while (hi - lo > 1e-8) {
    long double mid = (lo + hi) / 2;
    vector<seg> A;
    for (int i = 0; i < (N); i++) {
      pt sta = points[i];
      pt end = {points[i].x + dx[i] * mid, points[i].y + dy[i] * mid};
      A.push_back({sta, end, i});
    }
    if (solve(A).first == -1) {
      lo = mid;
    } else {
      hi = mid;
    }
  }
  if (lo > 7e15) {
    cout << "No show :(" << nl;
  } else {
    cout << setprecision(20) << lo << nl;
  }
  return 0;
}
