#include <bits/stdc++.h>
using namespace std;
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T>;
template <typename T>
using dpair = pair<T, T>;
template <class T1, class T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
  return is >> p.first >> p.second;
}
template <class T1, class T2>
void operator+=(vector<T1> &v, const T2 &obj) {
  v.push_back(obj);
}
template <class T1>
void operator+=(vector<T1> &v, const T1 &obj) {
  v.push_back(obj);
}
long long get_millis() {
  using namespace std::chrono;
  return duration_cast<milliseconds>(system_clock::now().time_since_epoch())
      .count();
}
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3fll;
const long long mod = 1e9 + 7;
class range {
 public:
  range(int end) : _start(0), _end(end), _step(1) {}
  range(int start, int end) : _start(start), _end(end), _step(1) {}
  range(int start, int end, int step) : _start(start), _end(end), _step(step) {}
  class iterator {
   public:
    iterator(int v, range &par) : val(v), parent(par){};
    int operator*() const { return val; }
    int operator++() { return (val += parent._step); }
    bool operator==(const range::iterator &iter) const {
      if (&parent != &iter.parent) {
        return false;
      }
      if (val == iter.val) {
        return true;
      }
      if (parent._step > 0) {
        return val >= parent._end && iter.val >= parent._end;
      } else {
        return val <= parent._end && iter.val <= parent._end;
      }
    }
    bool operator!=(const range::iterator &iter) const {
      return !(this->operator==(iter));
    }

   private:
    int val;
    range &parent;
  };
  range::iterator begin() { return {_start, *this}; }
  range::iterator end() { return {_end, *this}; }

 protected:
  int _start, _end, _step;

 private:
};
const int MAXN = 1e5 + 2;
int N;
struct {
  long long x1, y1, x2, y2;
} rect;
struct {
  long long rx, ry, vx, vy;
} mice[MAXN];
int main() {
  cin.tie(0);
  cin.sync_with_stdio(0);
  cin >> N;
  cin >> rect.x1 >> rect.y1 >> rect.x2 >> rect.y2;
  for (int i = 0; i < N; i++) {
    cin >> mice[i].rx >> mice[i].ry;
    cin >> mice[i].vx >> mice[i].vy;
    if (mice[i].vx == 0 && mice[i].vy == 0) {
      if (rect.y1 < mice[i].ry && rect.y2 > mice[i].ry &&
          rect.x1 < mice[i].rx && rect.x2 > mice[i].rx) {
        i--;
        N--;
      } else {
        cout << -1;
        return 0;
      }
    }
  }
  int req = 0;
  map<double, int> ranges;
  for (int i : range(N)) {
    if (mice[i].vx == 0) {
      if (rect.x1 < mice[i].rx && rect.x2 > mice[i].rx) {
      } else {
        cout << -1;
        return 0;
      }
    } else {
      double t1 = (rect.x1 - mice[i].rx) / (double)mice[i].vx;
      double t2 = (rect.x2 - mice[i].rx) / (double)mice[i].vx;
      t1 = max(0., t1);
      t2 = max(0., t2);
      if (t1 > t2) {
        swap(t1, t2);
      }
      ranges[t1]++;
      ranges[t2]--;
      req++;
    }
    if (mice[i].vy == 0) {
      if (rect.y1 < mice[i].ry && rect.y2 > mice[i].ry) {
      } else {
        cout << -1;
        return 0;
      }
    } else {
      double t1 = (rect.y1 - mice[i].ry) / (double)mice[i].vy;
      double t2 = (rect.y2 - mice[i].ry) / (double)mice[i].vy;
      if (t1 > t2) {
        swap(t1, t2);
      }
      t1 = max(0., t1);
      t2 = max(0., t2);
      ranges[t1]++;
      ranges[t2]--;
      req++;
    }
  }
  if (req == 0) {
    cout << 0;
    return 0;
  }
  int cnt = 0;
  for (pair<double, int> p : ranges) {
    cnt += p.second;
    if (cnt == req) {
      cout << fixed << setprecision(10) << p.first;
      return 0;
    }
  }
  cout << -1;
}
