#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto &x : v) {
    if (!first) res += ", ";
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
template <class T>
inline bool chmax(T &a, T b) {
  return a < b && (a = b, true);
}
template <class T>
inline bool chmin(T &a, T b) {
  return a > b && (a = b, true);
}
using ll = long long;
using P = pair<int, int>;
using T = tuple<int, int, int>;
constexpr int INF = 0x3f3f3f3f;
constexpr ll LLINF = 0x3f3f3f3f3f3f3f3f;
constexpr ll MOD = 1e9 + 7;
using db = double;
constexpr db EPS = 1e-9;
inline int sign(db x) { return x < -EPS ? -1 : x > EPS; }
inline int cmp(db x, db y) { return sign(x - y); }
struct Vec {
  db x, y;
  Vec() {}
  Vec(db _x, db _y) : x(_x), y(_y) {}
  Vec operator+(const Vec &p) const { return Vec(x + p.x, y + p.y); }
  Vec operator-(const Vec &p) const { return Vec(x - p.x, y - p.y); }
  Vec operator*(db k) const { return Vec(x * k, y * k); }
  Vec operator/(db k) const { return Vec(x / k, y / k); }
};
db dot(const Vec &a, const Vec &b) { return a.x * b.x + a.y * b.y; }
db det(const Vec &a, const Vec &b) { return a.x * b.y - a.y * b.x; }
bool left(const Vec &start, const Vec &dir, const Vec &p) {
  return sign(det(p - start, dir)) >= 0;
}
db curX;
struct Segment {
  Vec left, right;
  int idx;
  Segment(Vec a, Vec b, int _idx) : idx(_idx) {
    if (cmp(a.x, b.x) < 0) {
      left = a;
      right = b;
    } else {
      left = b;
      right = a;
    }
  }
  db getY(db x) const {
    return left.y + (x - left.x) * (right.y - left.y) / (right.x - left.x);
  }
  bool operator<(const Segment &b) const {
    db y1 = getY(curX);
    db y2 = b.getY(curX);
    if (cmp(y1, y2) != 0) {
      return cmp(y1, y2) < 0;
    }
    return idx < b.idx;
  }
};
bool intersect(const Segment &a, const Segment &b) {
  if (left(a.left, a.right - a.left, b.right)) {
    return left(a.right, a.left - a.right, b.left) &&
           left(b.left, b.right - b.left, a.left) &&
           left(b.right, b.left - b.right, a.right);
  } else {
    return left(a.left, a.right - a.left, b.left) &&
           left(b.left, b.right - b.left, a.right) &&
           left(b.right, b.left - b.right, a.left);
  }
}
bool hasIntersection(vector<Segment> &v) {
  vector<tuple<Vec, bool, int>> points;
  int N = v.size();
  for (__typeof(N) i = (0) - ((0) > (N)); i != (N) - ((0) > (N));
       i += 1 - 2 * ((0) > (N))) {
    points.emplace_back(v[i].left, true, i);
    points.emplace_back(v[i].right, false, i);
  }
  sort(begin(points), end(points),
       [](const tuple<Vec, bool, int> &a, const tuple<Vec, bool, int> &b) {
         return cmp(get<0>(a).x, get<0>(b).x) < 0;
       });
  set<Segment> tree;
  for (auto [p, isLeft, idx] : points) {
    curX = p.x;
    if (isLeft) {
      auto iter = tree.insert(v[idx]).first;
      if (iter != tree.begin()) {
        iter--;
        if (intersect(v[idx], *iter)) return true;
        iter++;
      }
      iter++;
      if (iter != tree.end() && intersect(v[idx], *iter)) return true;
    } else {
      auto iter = tree.find(v[idx]);
      if (iter != tree.begin()) {
        auto iter1 = iter;
        auto iter2 = iter;
        iter1--;
        iter2++;
        if (iter2 != tree.end() && intersect(*iter1, *iter2)) return true;
      }
      tree.erase(iter);
    }
  }
  return false;
}
int N;
vector<Vec> start, dir;
bool test(db t) {
  vector<Segment> v;
  for (__typeof(N) i = (0) - ((0) > (N)); i != (N) - ((0) > (N));
       i += 1 - 2 * ((0) > (N))) {
    v.emplace_back(start[i], start[i] + dir[i] * t, i);
  }
  return hasIntersection(v);
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cin >> N;
  for (__typeof(N) i = (0) - ((0) > (N)); i != (N) - ((0) > (N));
       i += 1 - 2 * ((0) > (N))) {
    int x, y, dx, dy, s;
    cin >> x >> y >> dx >> dy >> s;
    start.emplace_back(x, y);
    db len = sqrt(dx * dx + dy * dy);
    dir.emplace_back(s * dx / len, s * dy / len);
  }
  db ub = 1e11 + 10;
  db l = 0, r = ub;
  while (abs(r - l) / max(1.0, abs(r)) > 1e-7) {
    db mi = (l + r) / 2;
    if (test(mi))
      r = mi;
    else
      l = mi;
  }
  if (cmp(r, ub) == 0) {
    puts("No show :(");
  } else {
    printf("%.10f", r);
  }
}
