#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-12, PI = acos(-1);
inline bool eq(double a, double b) { return abs(b - a) < EPS; }
enum { OUT, ON, IN };
namespace Geometory {
struct Point {
  double x, y;
  Point(){};
  Point(double x, double y) : x(x), y(y){};
  Point operator+(const Point &b) const { return Point(x + b.x, y + b.y); }
  Point operator-(const Point &b) const { return Point(x - b.x, y - b.y); }
  Point operator*(const double b) const { return Point(x * b, y * b); }
  Point operator*(const Point &b) const {
    return Point(x * b.x - y * b.y, x * b.y + y * b.x);
  }
  Point operator/(const double b) const { return Point(x / b, y / b); }
  bool operator<(const Point &b) const { return x != b.x ? x < b.x : y < b.y; }
  bool operator==(const Point &b) const { return eq(x, b.x) && eq(y, b.y); }
  double norm() { return x * x + y * y; }
  double arg() { return atan2(x, y); }
  double abs() { return sqrt(norm()); }
  Point rotate(double theta) {
    return Point(cos(theta) * x - sin(theta) * y,
                 sin(theta) * x + cos(theta) * y);
  }
  Point rotate90() { return Point(-y, x); }
  friend ostream &operator<<(ostream &os, Point &p) {
    return os << "(" << p.x << "," << p.y << ")";
  }
  friend istream &operator>>(istream &is, Point &a) { return is >> a.x >> a.y; }
};
struct Line {
  Point a, b;
  Line(){};
  Line(Point a, Point b) : a(a), b(b){};
  friend ostream &operator<<(ostream &os, Line &p) {
    return os << "(" << p.a.x << "," << p.a.y << ") to (" << p.b.x << ","
              << p.b.y << ")";
  }
  friend istream &operator>>(istream &is, Line &a) {
    return is >> a.a.x >> a.a.y >> a.b.x >> a.b.y;
  }
};
struct Segment {
  Point a, b;
  Segment(){};
  Segment(Point a, Point b) : a(a), b(b){};
  friend ostream &operator<<(ostream &os, Segment &p) {
    return os << "(" << p.a.x << "," << p.a.y << ") to (" << p.b.x << ","
              << p.b.y << ")";
  }
  friend istream &operator>>(istream &is, Segment &a) {
    return is >> a.a.x >> a.a.y >> a.b.x >> a.b.y;
  }
};
struct Circle {
  Point p;
  double r;
  Circle(){};
  Circle(Point p, double r) : p(p), r(r){};
};
double cross(const Point &a, const Point &b) { return a.x * b.y - a.y * b.x; }
double dot(const Point &a, const Point &b) { return a.x * b.x + a.y * b.y; }
int ccw(const Point &a, Point b, Point c) {
  b = b - a, c = c - a;
  if (cross(b, c) > EPS) return +1;
  if (cross(b, c) < -EPS) return -1;
  if (dot(b, c) < 0) return +2;
  if (b.norm() < c.norm()) return -2;
  return 0;
}
Point Projection(const Line &l, const Point &p) {
  double t = dot(p - l.a, l.a - l.b) / (l.a - l.b).norm();
  return l.a + (l.a - l.b) * t;
}
Point Projection(const Segment &l, const Point &p) {
  double t = dot(p - l.a, l.a - l.b) / (l.a - l.b).norm();
  return l.a + (l.a - l.b) * t;
}
Point Reflection(const Line &l, const Point &p) {
  return p + (Projection(l, p) - p) * 2.0;
}
double Distance(const Line &l, const Point &p) {
  return (p - Projection(l, p)).abs();
}
bool Intersect(const Line &l, const Line &m) {
  return abs(cross(l.b - l.a, m.b - m.a)) > EPS ||
         abs(cross(l.b - l.a, m.b - l.a)) < EPS;
}
bool Intersect(const Line &l, const Segment &s) {
  return cross(l.b - l.a, s.a - l.a) * cross(l.b - l.a, s.b - l.a) < EPS;
}
bool Intersect(const Line &l, const Point &p) {
  return abs(ccw(l.a, l.b, p)) != -1;
}
bool Intersect(const Segment &s, const Segment &t) {
  return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
         ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
bool Intersect(const Segment &s, const Point &p) {
  return ccw(s.a, s.b, p) == 0;
}
bool Intersect(const Circle &c, const Line &l) {
  return Distance(l, c.p) <= c.r + EPS;
}
bool Intersect(const Circle &c, const Point &p) {
  return abs((p - c.p).abs() - c.r) < EPS;
}
int Intersect(const Circle &c, const Segment &l) {
  if ((Projection(l, c.p) - c.p).norm() - c.r * c.r > EPS) return 0;
  const double d1 = (c.p - l.a).abs(), d2 = (c.p - l.b).abs();
  if (d1 < c.r + EPS && d2 < c.r + EPS) return 0;
  if (d1 < c.r - EPS && d2 > c.r + EPS || d1 > c.r + EPS && d2 < c.r - EPS)
    return 1;
  const Point h = Projection(l, c.p);
  if (dot(l.a - h, l.b - h) < 0) return 2;
  return 0;
}
bool Intersect(const Circle &a, const Circle &b) {
  return ((a.p - b.p).norm() - (a.r + b.r) * (a.r + b.r) < EPS) &&
         ((a.p - b.p).norm() - (a.r - b.r) * (a.r - b.r) > -EPS);
}
double Distance(const Segment &s, const Point &p) {
  Point r = Projection(s, p);
  if (Intersect(s, r)) return (r - p).abs();
  return min((s.a - p).abs(), (s.b - p).abs());
}
double Distance(const Segment &a, const Segment &b) {
  if (Intersect(a, b)) return 0;
  return min(min(Distance(a, b.a), Distance(a, b.b)),
             min(Distance(b, a.a), Distance(b, a.b)));
}
double Distance(const Line &l, const Line &m) {
  return Intersect(l, m) ? 0 : Distance(l, m.a);
}
double Distance(const Line &l, const Segment &s) {
  if (Intersect(l, s)) return 0;
  return min(Distance(l, s.a), Distance(l, s.b));
}
double Distance(const Point &a, const Point &b) { return (a - b).abs(); }
Point Crosspoint(const Segment &l, const Segment &m) {
  double A = cross(l.b - l.a, m.b - m.a);
  double B = cross(l.b - l.a, l.b - m.a);
  if (abs(A) < EPS && abs(B) < EPS) return m.a;
  return m.a + (m.b - m.a) * B / A;
}
Point Crosspoint(const Line &l, const Segment &m) {
  double A = cross(l.b - l.a, m.b - m.a);
  double B = cross(l.b - l.a, l.b - m.a);
  if (abs(A) < EPS && abs(B) < EPS) return m.a;
  return m.a + (m.b - m.a) * B / A;
}
pair<Point, Point> Crosspoint(const Circle &c, const Line l) {
  Point hp = Projection(l, c.p), h = hp - c.p;
  const double d2 = h.norm();
  Point v = (l.b - l.a) * sqrt(c.r * c.r - d2) / (l.b - l.a).abs();
  return pair<Point, Point>(hp - v, hp + v);
}
pair<Point, Point> Crosspoint(const Circle &c, const Segment &l) {
  Line aa = Line(l.a, l.b);
  if (Intersect(c, l) == 2) return Crosspoint(c, aa);
  pair<Point, Point> ret = Crosspoint(c, aa);
  if (dot(l.a - ret.first, l.b - ret.first) < 0)
    ret.second = ret.first;
  else
    ret.first = ret.second;
  return ret;
}
pair<Point, Point> Crosspoint(const Circle &c1, const Circle &c2) {
  double d = (c1.p - c2.p).abs();
  double s = (c1.r + c2.r + d) / 2;
  double S = sqrt(s * (s - c1.r) * (s - c2.r) * (s - d));
  double h = 2 * S / d;
  Point v = (c2.p - c1.p) / (c2.p - c1.p).abs();
  double m = sqrt(c1.r * c1.r - h * h);
  return pair<Point, Point>(c1.p + v * m + Point(0, 1) * h * v,
                            c1.p + v * m - Point(0, 1) * h * v);
}
bool parallel(const Line &a, const Line &b) {
  return abs(cross(a.b - a.a, b.b - b.a)) < EPS;
}
bool orthogonal(const Line &a, const Line &b) {
  return abs(dot(a.a - a.b, b.a - b.b)) < EPS;
}
int Contains(const vector<Point> &Q, const Point &p) {
  bool in = false;
  for (int i = 0; i < Q.size(); i++) {
    Point a = Q[i] - p, b = Q[(i + 1) % Q.size()] - p;
    if (a.y > b.y) swap(a, b);
    if (a.y <= 0 && 0 < b.y && cross(a, b) < 0) in = !in;
    if (cross(a, b) == 0 && dot(a, b) <= 0) return ON;
  }
  return in ? IN : OUT;
}
bool Contains(const Circle &c, const Point &p) {
  return (c.p - p).abs() < c.r + EPS;
}
double Area2(const vector<Point> &p) {
  double A = 0;
  for (int i = 0; i < p.size(); ++i) {
    A += cross(p[i], p[(i + 1) % p.size()]);
  }
  return A;
}
bool IsConvex(const vector<Point> &p) {
  for (int i = 0; i < p.size(); i++) {
    if (ccw(p[(i + p.size() - 1) % p.size()], p[i], p[(i + 1) % p.size()]) ==
        -1)
      return false;
  }
  return true;
}
vector<Point> Convex_Hull(vector<Point> &p) {
  int n = p.size(), k = 0;
  if (n >= 3) {
    sort(p.begin(), p.end());
    vector<Point> ch(2 * n);
    for (int i = 0; i < n; ch[k++] = p[i++]) {
      while (k >= 2 && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 1]) < 0) --k;
    }
    for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = p[i--]) {
      while (k >= t && cross(ch[k - 1] - ch[k - 2], p[i] - ch[k - 1]) < 0) --k;
    }
    ch.resize(k - 1);
    return ch;
  } else {
    return p;
  }
}
double Convex_Diameter(vector<Point> &p) {
  int n = p.size();
  int is = 0, js = 0;
  for (int i = 1; i < n; i++) {
    if (p[i].y > p[is].y) is = i;
    if (p[i].y < p[js].y) js = i;
  }
  double maxdis = (p[is] - p[js]).norm();
  int maxi, maxj, i, j;
  i = maxi = is;
  j = maxj = js;
  do {
    if (cross(p[(i + 1) % p.size()] - p[i], p[(j + 1) % p.size()] - p[j]) >=
        0) {
      j = (j + 1) % n;
    } else {
      i = (i + 1) % n;
    }
    if ((p[i] - p[j]).norm() > maxdis) {
      maxdis = (p[i] - p[j]).norm();
      maxi = i;
      maxj = j;
    }
  } while (i != is || j != js);
  return maxdis;
}
};  // namespace Geometory
using namespace Geometory;
int main() {
  int N, X[100000], Y[100000];
  cin >> N;
  int a, b, c, d;
  cin >> a >> b >> c >> d;
  if (a == c || b == d) {
    cout << -1 << endl;
    return (0);
  }
  vector<Point> polygon(4);
  polygon[0] = Point(c, d);
  polygon[1] = Point(a, d);
  polygon[2] = Point(a, b);
  polygon[3] = Point(c, b);
  double latte = 0, malta = 1e64;
  for (int i = 0; i < N; i++) {
    Line seg;
    cin >> seg;
    vector<Point> cross;
    seg.b = seg.a + seg.b;
    if (seg.a == seg.b) {
      if (Contains(polygon, seg.a) != IN) {
        cout << -1 << endl;
        return (0);
      }
      continue;
    }
    bool aaa = seg.a.x < seg.b.x, bbb = seg.a.y < seg.b.y;
    double dists = Distance(seg.a, seg.b);
    for (int j = 0; j < 4; j++) {
      Segment seq(polygon[j], polygon[(j + 1) % polygon.size()]);
      if (!Intersect(seg, seq)) continue;
      auto get = Crosspoint(seg, seq);
      bool ccc = seg.a.x < get.x, ddd = seg.a.y < get.y;
      if (seg.a.x != get.x) {
        if (ccc != aaa) continue;
      }
      if (seg.a.y != get.y) {
        if (ddd != bbb) continue;
      }
      cross.push_back(get);
    }
    if (Contains(polygon, seg.a) == IN) {
      cross.emplace_back(seg.a);
    }
    if (cross.size() <= 1) {
      cout << -1 << endl;
      return (0);
    }
    bool vv[4] = {}, other = true;
    for (auto &q : cross) {
      int comp = false;
      for (int j = 0; j < 4; j++) {
        vv[j] |= polygon[j] == q;
        if (polygon[j] == q) comp = true;
      }
      if (!comp) other = false;
    }
    if (other) {
      if ((vv[0] & vv[2]) || (vv[1] & vv[3])) {
      } else {
        cout << -1 << endl;
        return (0);
      }
    }
    double bit = 0, uku = 1e64;
    for (auto &p : cross) {
      bit = max(bit, Distance(p, seg.a) / dists);
      uku = min(uku, Distance(p, seg.a) / dists);
    }
    latte = max(latte, uku);
    malta = min(malta, bit);
  }
  if (latte + EPS > malta)
    cout << -1 << endl;
  else
    cout << fixed << setprecision(15) << latte << endl;
}
