#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
int sgn(double t) { return abs(t) < EPS ? 0 : (t > 0) - (t < 0); }
struct PT {
  double x, y;
  PT(double x = 0, double y = 0) : x(x), y(y) {}
  PT operator-(PT o) { return PT(x - o.x, y - o.y); }
  PT operator*(double t) { return PT(x * t, y * t); }
  PT operator/(double t) { return PT(x / t, y / t); }
  PT operator+(PT o) { return PT(x + o.x, y + o.y); }
  bool operator<(const PT& o) const {
    return sgn(x - o.x) == 0 ? y < o.y : x < o.x;
  }
};
double dot(PT u, PT v) { return u.x * v.x + u.y * v.y; }
double cross(PT u, PT v) { return u.x * v.y - v.x * u.y; }
double orient(PT a, PT b, PT c) { return cross(b - a, c - a); }
bool onSegment(PT a, PT b, PT p) {
  return sgn(orient(a, b, p)) == 0 && sgn(dot(p - a, p - b)) <= 0;
}
bool intersect(PT a, PT b, PT c, PT d) {
  bool aux = sgn(orient(c, d, a)) * sgn(orient(c, d, b)) < 0 &&
                 sgn(orient(a, b, c)) * sgn(orient(a, b, d)) < 0 ||
             onSegment(c, d, a) || onSegment(c, d, b) || onSegment(a, b, c) ||
             onSegment(a, b, d);
  return aux;
}
double ord(PT a, PT b, double x) {
  double dx = b.x - a.x, ans = a.y;
  if (sgn(dx) != 0) ans += (b.y - a.y) / dx * (x - a.x);
  return ans;
}
bool intersect(vector<pair<PT, PT>>& v) {
  vector<tuple<double, bool, double, int>> e;
  for (int i = 0; i < v.size(); i++) {
    if (v[i].second < v[i].first) swap(v[i].first, v[i].second);
    e.emplace_back(v[i].first.x, false, v[i].first.y, i);
    e.emplace_back(v[i].second.x, true, v[i].second.y, i);
  }
  sort(e.begin(), e.end());
  set<int, function<bool(int, int)>> s([&](int i, int j) {
    double x = max(v[i].first.x, v[j].first.x);
    return sgn(ord(v[i].first, v[i].second, x) -
               ord(v[j].first, v[j].second, x)) < 0;
  });
  auto previous = [&](set<int>::iterator it) {
    return it == s.begin() ? s.end() : --it;
  };
  for (auto [x, close, y, i] : e) {
    auto suc = s.upper_bound(i);
    if (close) {
      auto it = s.find(i);
      if (suc != s.end()) {
        PT &a = v[*suc].first, b = v[*suc].second;
        auto pre = previous(it);
        if (pre != s.end() && intersect(v[*pre].first, v[*pre].second, a, b))
          return true;
      }
      s.erase(it);
    } else {
      PT &a = v[i].first, b = v[i].second;
      auto pre = previous(suc);
      if (pre != s.end() && intersect(v[*pre].first, v[*pre].second, a, b) ||
          suc != s.end() && intersect(v[*suc].first, v[*suc].second, a, b))
        return true;
      s.insert(suc, i);
    }
  }
  return false;
}
double abs(PT p) { return hypot(p.x, p.y); }
int main() {
  int n;
  scanf("%d", &n);
  vector<PT> pos, dir;
  vector<int> speed(n);
  for (int i = 0; i < n; i++) {
    int x, y;
    scanf("%d %d", &x, &y);
    pos.emplace_back(x, y);
    scanf("%d %d", &x, &y);
    dir.emplace_back(x, y);
    dir[i] = dir[i] / abs(dir[i]);
    scanf("%d", &speed[i]);
  }
  double l = 0, r = 1e10, t;
  for (int i = 0; i < 60; i++) {
    t = (l + r) / 2.0;
    vector<pair<PT, PT>> v;
    for (int i = 0; i < n; i++) {
      PT dis = dir[i] * (speed[i] * t);
      v.emplace_back(pos[i], pos[i] + dis);
    }
    if (intersect(v))
      r = t;
    else
      l = t;
  }
  if (abs(t - 1e10) < 1e-3)
    printf("No show :(\n");
  else
    printf("%.6lf\n", t);
}
