#include <bits/stdc++.h>
using namespace std;
template <class T>
struct rge {
  T b, e;
};
template <class T>
rge<T> range(T i, T j) {
  return rge<T>{i, j};
}
struct debug {
  template <class T>
  debug& operator<<(const T&) {
    return *this;
  }
};
using ll = long long;
using ld = long double;
template <typename T>
void min_self(T& a, T b) {
  a = min(a, b);
}
template <typename T>
void max_self(T& a, T b) {
  a = max(a, b);
}
using ll = long long;
using ld = long double;
template <typename p_type>
struct Point {
  p_type x, y;
  Point(p_type _x = 0, p_type _y = 0) : x(_x), y(_y) {}
  bool operator==(Point rhs) const {
    return fabs(x - rhs.x) < 1e-12 && fabs(y - rhs.y) < 1e-12;
  }
  bool operator<(Point rhs) const { return tie(x, y) < tie(rhs.x, rhs.y); }
  Point operator+(Point rhs) const { return Point(x + rhs.x, y + rhs.y); }
  Point operator-(Point rhs) const { return Point(x - rhs.x, y - rhs.y); }
};
template <typename p_type>
ostream& operator<<(ostream& out, Point<p_type> p) {
  return out << fixed << setprecision(3) << "(" << p.x << ", " << p.y << ")";
}
template <typename p_type>
istream& operator>>(istream& in, Point<p_type>& p) {
  return in >> p.x >> p.y;
}
template <typename v_type>
struct Vec {
  v_type x, y;
  Vec(v_type _x = 0, v_type _y = 0) : x(_x), y(_y) {}
  Vec(Point<v_type> a, Point<v_type> b) {
    x = b.x - a.x;
    y = b.y - a.y;
  }
  Vec operator+(Vec rhs) const { return Vec(x + rhs.x, y + rhs.y); }
  Vec operator-(Vec rhs) const { return Vec(x - rhs.x, y - rhs.y); }
  Vec& scale(v_type s) { return *this = Vec(x * s, y * s); }
  Vec& normalize() {
    assert(mag() > 1e-12);
    return scale(1. / mag());
  }
  Vec& rot(ld theta) {
    v_type new_x = x * cos(theta) - y * sin(theta);
    v_type new_y = x * sin(theta) + y * cos(theta);
    return *this = Vec(new_x, new_y);
  }
  v_type dot(Vec rhs) const { return x * rhs.x + y * rhs.y; }
  v_type cross(Vec rhs) const { return x * rhs.y - y * rhs.x; }
  ld mag() const { return sqrtl((ld)x * x + (ld)y * y); }
};
using P = Point<ld>;
using V = Vec<ld>;
bool angleCmp(P a, P b) {
  V va(a.x, a.y), vb(b.x, b.y);
  if (va.cross(vb) == 0) {
    return va.mag() < vb.mag();
  } else {
    return va.cross(vb) > 0;
  }
}
ld dist(P a, P b) {
  return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
ld angle(V u, V v) { return acos(u.dot(v) / (u.mag() * v.mag())); }
int orientation(P p, P q, P r) {
  ld v = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
  if (fabs(v) < 1e-12) {
    return 0;
  } else {
    return v > 0 ? 1 : 2;
  }
}
bool onSeg(P p, P q, P r) {
  return min(p.x, r.x) <= q.x && q.x <= max(p.x, r.x) && min(p.y, r.y) <= q.y &&
         q.y <= max(p.y, r.y);
}
bool intersectSeg(P p1, P q1, P p2, P q2) {
  int o1 = orientation(p1, q1, p2);
  int o2 = orientation(p1, q1, q2);
  int o3 = orientation(p2, q2, p1);
  int o4 = orientation(p2, q2, q1);
  if (o1 != o2 && o3 != o4) {
    return true;
  }
  if (o1 == 0 && onSeg(p1, p2, q1)) {
    return true;
  }
  if (o2 == 0 && onSeg(p1, q2, q1)) {
    return true;
  }
  if (o3 == 0 && onSeg(p2, p1, q2)) {
    return true;
  }
  if (o4 == 0 && onSeg(p2, q1, q2)) {
    return true;
  }
  return false;
}
struct Seg {
  P p, q;
  ld eval(ld x) const {
    assert(fabs(p.x - q.x) > 1e-12);
    return p.y + (q.y - p.y) * (x - p.x) / (q.x - p.x);
  }
  bool operator<(const Seg& rhs) const {
    ld x = max(min(p.x, q.x), min(rhs.p.x, rhs.q.x));
    return eval(x) < rhs.eval(x);
  }
};
bool intersect(Seg a, Seg b) { return intersectSeg(a.p, a.q, b.p, b.q); }
struct Event {
  ld x;
  int type, idx;
  Event() {}
  Event(ld _x, int _type, int _idx) : x(_x), type(_type), idx(_idx) {}
  bool operator<(const Event& rhs) const {
    if (fabs(x - rhs.x)) {
      return x < rhs.x;
    } else {
      return type > rhs.type;
    }
  }
};
set<Seg> s;
vector<set<Seg>::iterator> where;
set<Seg>::iterator prev(set<Seg>::iterator it) {
  return it == s.begin() ? s.end() : --it;
}
set<Seg>::iterator next(set<Seg>::iterator it) { return ++it; }
bool isIntesection(vector<Seg> a) {
  int n = a.size();
  vector<Event> events;
  for (int i = 0; i < n; i++) {
    events.emplace_back(min(a[i].p.x, a[i].q.x), 1, i);
    events.emplace_back(max(a[i].p.x, a[i].q.x), 0, i);
  }
  sort(events.begin(), events.end());
  s.clear();
  where.resize(n);
  for (Event e : events) {
    if (e.type == 1) {
      auto nxt = s.lower_bound(a[e.idx]), prv = prev(nxt);
      if (nxt != s.end() && intersect(*nxt, a[e.idx])) {
        return true;
      }
      if (prv != s.end() && intersect(*prv, a[e.idx])) {
        return true;
      }
      where[e.idx] = s.insert(nxt, a[e.idx]);
    } else {
      auto nxt = next(where[e.idx]), prv = prev(where[e.idx]);
      if (nxt != s.end() && prv != s.end() && intersect(*nxt, *prv)) {
        return true;
      }
      s.erase(where[e.idx]);
    }
  }
  return false;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout << fixed << setprecision(10);
  int n;
  cin >> n;
  vector<int> x(n), y(n), dx(n), dy(n), speed(n);
  vector<ld> norm(n);
  for (int i = 0; i < int(n); i++) {
    cin >> x[i] >> y[i] >> dx[i] >> dy[i] >> speed[i];
    norm[i] = hypot(dx[i], dy[i]);
  }
  const ll inf = 1e12;
  const ld eps2 = 1e-7;
  ld lo = 0, hi = inf;
  ld old = inf;
  for (;;) {
    vector<Seg> a;
    ld mid = (lo + hi) / 2;
    if (fabs(mid - old) / old < eps2) {
      break;
    }
    for (int i = 0; i < n; i++) {
      P p = P(x[i], y[i]);
      P q = p;
      q.x += speed[i] * mid * dx[i] / norm[i];
      q.y += speed[i] * mid * dy[i] / norm[i];
      a.push_back({p, q});
    }
    if (isIntesection(a)) {
      hi = mid;
    } else {
      lo = mid;
    }
    old = mid;
  }
  if (fabs(hi - inf) < 1e-12) {
    cout << "No show :(\n";
  } else {
    cout << lo << '\n';
  }
}
