#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target( \
    "sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("section-anchors")
#pragma GCC optimize("profile-values,profile-reorder-functions,tracer")
#pragma GCC optimize("vpt")
#pragma GCC optimize("rename-registers")
#pragma GCC optimize("move-loop-invariants")
#pragma GCC optimize("unswitch-loops")
#pragma GCC optimize("function-sections")
#pragma GCC optimize("data-sections")
#pragma GCC optimize("branch-target-load-optimize")
#pragma GCC optimize("branch-target-load-optimize2")
#pragma GCC optimize("btr-bb-exclusive")
using namespace std;
double my_sqrt(double x) { return x < 0 ? 0 : sqrt(x); }
int sign(double x) {
  if (abs(x) <= 1e-6) {
    return 0;
  }
  return x < 0 ? -1 : +1;
}
namespace myg2d {
const long double PI = ::atan2(0, -1);
struct Point;
struct Vector;
double dist2(Point A, Point B);
double dist(Point A, Point B);
double dot_product(Vector a, Vector b);
double cross_product(Vector a, Vector b);
Point operator+(Point A, Vector a);
Vector operator*(Vector a, double k);
struct Point {
  double x, y;
  Point() {}
  Point(double _x, double _y) : x(_x), y(_y) {}
};
struct Vector {
  double x, y;
  Vector() {}
  Vector(double _x, double _y) : x(_x), y(_y) {}
  Vector(Point A) : x(A.x), y(A.y) {}
  Vector(Point A, Point B) : x(B.x - A.x), y(B.y - A.y) {}
};
struct Ray {
  Point O;
  Vector r;
  Ray() {}
  Ray(Point _O, Vector _r) : O(_O), r(_r) {}
  Ray(Point A, Point B) : O(A), r(A, B) {}
};
struct Line {
  double a, b, c;
  double get(Point A) { return a * A.x + b * A.y + c; }
  Vector dir_vec() { return Vector(-b, a); }
  double operator()(Point A) { return get(A); }
  Point operator[](int i) {
    return Point(-a * c / (a * a + b * b), -b * c / (a * a + b * b)) +
           dir_vec() * i;
  }
  void init(Point A, Point B) {
    a = A.y - B.y;
    b = B.x - A.x;
    c = -(a * A.x + b * A.y);
  }
  Line() {}
  Line(double _a, double _b, double _c) : a(_a), b(_b), c(_c) {}
  Line(Point A, Point B) { init(A, B); }
  Line(Point A, Vector r) { init(A, A + r); }
  Line(Ray f) { init(f.O, f.O + f.r); }
};
bool operator==(Line n, Line m) {
  return n.a * m.b == n.b * m.a && n.b * m.c == n.c * m.b &&
         n.c * m.a == n.a * m.c;
}
Vector operator*(double k, Vector a) { return {a.x * k, a.y * k}; }
Vector operator*(Vector a, double k) { return k * a; }
Point operator+(Point A, Vector a) { return {A.x + a.x, A.y + a.y}; }
double dist2(Point A, Point B) {
  return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y);
}
double dist(Point A, Point B) { return my_sqrt(dist2(A, B)); }
double dot_product(Vector a, Vector b) { return a.x * b.x + a.y * b.y; }
double cross_product(Vector a, Vector b) { return a.x * b.y - a.y * b.x; }
const double EPS = 1e-6;
bool on(Point P, Ray g) {
  return dot_product(g.r, Vector(g.O, P)) >= -EPS &&
         abs(cross_product(g.r, Vector(g.O, P))) <= EPS;
}
bool is_collinear(Vector a, Vector b) {
  return abs(cross_product(a, b)) <= EPS;
}
Point good_intersect(Line n, Line m) {
  double y = (n.a * m.c - n.c * m.a) / (n.b * m.a - n.a * m.b);
  double x = (n.b * m.c - n.c * m.b) / (n.a * m.b - n.b * m.a);
  return Point(x, y);
}
vector<Point> intersect(Line n, Line m) {
  return is_collinear(n.dir_vec(), m.dir_vec())
             ? n == m ? vector<Point>(2) : vector<Point>(0)
             : vector<Point>({good_intersect(n, m)});
}
}  // namespace myg2d
using namespace myg2d;
const int N = 25000;
int n;
struct Item {
  Ray h;
  int v;
} a[N];
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  cout.precision(47);
  cout << fixed;
  int start = clock();
  cin >> n;
  for (int i = 0; i < n; ++i) {
    int x, y, dx, dy, s;
    cin >> x >> y >> dx >> dy >> s;
    a[i] = {Ray(Point(x, y), Vector(dx, dy)), s};
  }
  double ans = 1e18;
  vector<int> kek;
  for (int i = 0; i < n; ++i) {
    kek.push_back(i);
  }
  mt19937 rnd(239);
  shuffle(kek.begin(), kek.end(), rnd);
  const int KEK = 5900;
  for (auto k = 0; k < kek.size(); ++k) {
    int i = kek[k];
    if (clock() - start > KEK) {
      break;
    }
    for (int jk = 0; jk < k; ++jk) {
      int j = kek[jk];
      if (clock() - start > KEK) {
        break;
      }
      if (abs(dist(a[i].h.O, a[j].h.O)) / (a[i].v + a[j].v) > ans) {
        continue;
      }
      auto arr = intersect(Line(a[i].h), Line(a[j].h));
      if (arr.size() == 1) {
        Point P = arr[0];
        if (on(P, a[i].h) && on(P, a[j].h)) {
          ans = min(ans, max(abs(dist(P, a[i].h.O)) / a[i].v,
                             abs(dist(P, a[j].h.O)) / a[j].v));
        }
      } else if (arr.size() == 2) {
        if (on(a[i].h.O, a[j].h) && on(a[j].h.O, a[i].h)) {
          ans = min(ans, abs(dist(a[i].h.O, a[j].h.O)) / (a[i].v + a[j].v));
        } else if (on(a[i].h.O, a[j].h)) {
          ans = min(ans, abs(dist(a[i].h.O, a[j].h.O)) / a[j].v);
        } else if (on(a[j].h.O, a[i].h)) {
          ans = min(ans, abs(dist(a[i].h.O, a[j].h.O)) / a[i].v);
        }
      }
    }
  }
  if (ans >= 5e17) {
    cout << "No show :(\n";
  } else {
    cout << ans << '\n';
  }
  return 0;
}
