Igor the analyst fell asleep on the work and had a strange dream. In the dream his desk was crowded with computer mice, so he bought a mousetrap to catch them.

The desk can be considered as an infinite plane, then the mousetrap is a rectangle which sides are parallel to the axes, and which opposite sides are located in points (x1, y1) and (x2, y2).

Igor wants to catch all mice. Igor has analysed their behavior and discovered that each mouse is moving along a straight line with constant speed, the speed of the i-th mouse is equal to (vix, viy), that means that the x coordinate of the mouse increases by vix units per second, while the y coordinates increases by viy units. The mousetrap is open initially so that the mice are able to move freely on the desk. Igor can close the mousetrap at any moment catching all the mice that are strictly inside the mousetrap.

Igor works a lot, so he is busy in the dream as well, and he asks you to write a program that by given mousetrap's coordinates, the initial coordinates of the mice and their speeds determines the earliest time moment in which he is able to catch all the mice. Please note that Igor can close the mousetrap only once.

Input

The first line contains single integer n (1 ≤ n ≤ 100 000) — the number of computer mice on the desk.

The second line contains four integers x1, y1, x2 and y2 (0 ≤ x1 ≤ x2 ≤ 100 000), (0 ≤ y1 ≤ y2 ≤ 100 000) — the coordinates of the opposite corners of the mousetrap.

The next n lines contain the information about mice.

The i-th of these lines contains four integers rix, riy, vix and viy, (0 ≤ rix, riy ≤ 100 000,  - 100 000 ≤ vix, viy ≤ 100 000), where (rix, riy) is the initial position of the mouse, and (vix, viy) is its speed.

Output

In the only line print minimum possible non-negative number t such that if Igor closes the mousetrap at t seconds from the beginning, then all the mice are strictly inside the mousetrap. If there is no such t, print -1.

Your answer is considered correct if its absolute or relative error doesn't exceed 10 - 6. 

Formally, let your answer be a, and the jury's answer be b. Your answer is considered correct if <image>.

Examples

Input

4
7 7 9 8
3 5 7 5
7 5 2 4
3 3 7 8
6 6 3 2


Output

0.57142857142857139685


Input

4
7 7 9 8
0 3 -5 4
5 0 5 4
9 9 -1 -6
10 5 -7 -10


Output

-1

Note

Here is a picture of the first sample

Points A, B, C, D - start mice positions, segments are their paths.

<image>

Then, at first time when all mice will be in rectangle it will be looks like this:

<image>

Here is a picture of the second sample

<image>

Points A, D, B will never enter rectangle.
#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;
}
