#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-12;
struct Vec {
  double x;
  double y;
  Vec() = default;
  Vec(double x, double y) : x(x), y(y) {}
  void read() { cin >> x >> y; }
  void print() const { cout << x << ' ' << y << endl; }
  Vec operator+(const Vec& other) const { return {x + other.x, y + other.y}; }
  Vec operator-(const Vec& other) const { return {x - other.x, y - other.y}; }
};
double det(double a1, double a2, double b1, double b2) {
  return a1 * b2 - a2 * b1;
}
struct Line {
  double a;
  double b;
  double c;
  Line() = default;
  Line(const Vec& p1, const Vec& p2)
      : a(p2.y - p1.y), b(p1.x - p2.x), c(-det(p1.x, p1.y, p2.x, p2.y)) {}
  bool contains(const Vec& p) const {
    double val = a * p.x + b * p.y + c;
    return abs(val) < EPS;
  }
};
struct Seg {
  Vec mn;
  Vec mx;
  Seg() = default;
  Seg(const Vec& a, const Vec& b)
      : mn(min(a.x, b.x), min(a.y, b.y)), mx(max(a.x, b.x), max(a.y, b.y)) {}
  bool contains(const Vec& p) const {
    return mn.x - EPS <= p.x && p.x - EPS <= mx.x && mn.y - EPS <= p.y &&
           p.y - EPS <= mx.y;
  }
};
double cross_product(const Vec& a, const Vec& b) {
  return det(a.x, a.y, b.x, b.y);
}
double get_tr(const Vec& a, const Vec& b, const Vec& c) {
  return abs(cross_product(a - b, c - b));
}
bool inside(const vector<Vec>& poly, const Vec& p) {
  double sq = 0;
  for (int i = 0; i < 4; ++i) {
    sq += get_tr(poly[i], p, poly[(i + 1) % 4]);
  }
  double sq2 = 0;
  sq2 += cross_product(poly[1] - poly[0], poly[2] - poly[0]);
  sq2 += cross_product(poly[2] - poly[0], poly[3] - poly[0]);
  sq2 = abs(sq2);
  return abs(sq - sq2) < EPS;
}
bool cmp(double a, double b) { return abs(a - b) < EPS; }
void no() {
  puts("-1");
  exit(0);
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(12);
  int n;
  cin >> n;
  Vec a, b;
  a.read();
  b.read();
  vector<Vec> poly(4);
  vector<Line> lines(4);
  vector<Seg> segs(4);
  poly[0] = a;
  poly[1] = {a.x, b.y};
  poly[2] = b;
  poly[3] = {b.x, a.y};
  for (int i = 0; i < 4; ++i) {
    lines[i] = {poly[i], poly[(i + 1) % 4]};
    segs[i] = {poly[i], poly[(i + 1) % 4]};
  }
  vector<pair<double, double>> ti;
  for (int i = 0; i < n; ++i) {
    Vec pos, sp;
    pos.read();
    sp.read();
    bool ins = inside(poly, pos);
    if (abs(sp.x) < EPS && abs(sp.y) < EPS) {
      for (int j = 0; j < 4; ++j) {
        if (lines[j].contains(pos) && segs[j].contains(pos)) {
          no();
        }
      }
      if (!ins) {
        no();
      }
      continue;
    }
    Line curln(pos, pos + sp);
    vector<Vec> c;
    for (int j = 0; j < 4; ++j) {
      double d = det(curln.a, curln.b, lines[j].a, lines[j].b);
      double d1 = det(-curln.c, curln.b, -lines[j].c, lines[j].b);
      double d2 = det(curln.a, -curln.c, lines[j].a, -lines[j].c);
      if (abs(d) < EPS) {
        if (abs(d1) < EPS && abs(d2) < EPS) {
          no();
        }
      }
      Vec mb(d1 / d, d2 / d);
      if (segs[j].contains(mb)) {
        c.push_back(mb);
      }
    }
    vector<double> t;
    if (ins) {
      t.push_back(0);
    }
    for (auto p : c) {
      Vec cur = p - pos;
      double k;
      if (abs(sp.x) < EPS) {
        k = cur.y / sp.y;
      } else {
        k = cur.x / sp.x;
      }
      if (k < EPS) {
        continue;
      }
      t.push_back(k);
    }
    sort(t.begin(), t.end());
    t.erase(unique(t.begin(), t.end(), cmp), t.end());
    if (t.size() < 2) {
      no();
    }
    ti.push_back({t[0] + EPS, t.back() - EPS});
  }
  if (ti.empty()) {
    cout << 0 << endl;
    return 0;
  }
  double min_t = ti[0].first;
  double max_t = ti[0].second;
  for (int i = 0; i < ti.size(); ++i) {
    min_t = max(min_t, ti[i].first);
    max_t = min(max_t, ti[i].second);
  }
  if (min_t > max_t) {
    no();
  }
  cout << min_t << endl;
  return 0;
}
