#pragma GCC optimize("O3,unroll-loops")
#include<bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
typedef long long LL;
typedef unsigned long long ULL;
#define all(x) ((x).begin()), ((x).end())
#define pb push_back
typedef double D;
struct P {
    D x, y;
    void print() const{
        printf("%.6f %.6f\n", x, y);
    }
    P operator + (const P & b) const { return P{x + b.x, y + b.y}; }
    P operator - (const P & b) const { return P{x - b.x, y - b.y}; }
    D operator * (const P & b) const {
        return x * b.y - y * b.x;
    }
};
P operator * (const D & x, const P & b) { return P{x * b.x, x * b.y}; }
struct L {
    P s, d;
    bool contains(const P & x) {
        return d * (x - s) > 0;
    }
};
P intersect(const L & a, const L & b) {
    D lambda = (b.s - a.s) * b.d / (a.d * b.d);
    return a.s + lambda * a.d;
}
vector<P> uh[2], lh[2];
vector<P> compute_uh(vector<L> & lines) {
    sort(lines.begin(), lines.end(), [&](const L & a, const L & b) {
        return a.d.y < b.d.y || a.d.y == b.d.y && a.s.x < b.s.x;
    });
    vector<L> res;
    res.pb(L{P{0, 0}, P{0, -1}});
    for(int i = 0, j; i < (int)lines.size(); i = j) {
        for(j = i; j < (int)lines.size() && lines[i].d.y == lines[j].d.y; j++);
        L & l(lines[j - 1]);
        while(res.size() >= 2) {
            P i = intersect(res.back(), res[res.size() - 2]);
            if(!l.contains(i)) {
                res.pop_back();
            } else {
                break;
            }
        }
        res.pb(l);
    }
    vector<P> uh;
    for(int i = 0; i + 1 < (int)res.size(); i++) {
        uh.pb(intersect(res[i], res[i + 1]));
    }
    uh.pb(intersect(res.back(), L{P{1e10, 1e10}, P{0, -1}}));
    return uh;
}
D gety(const P & a, const P & b, const D & x) {
    return a.y + (b.y - a.y) * (x - a.x) / (b.x - a.x);
}
const int N = 1000011;
int x[N][2], vx[N][2];
int main() {
    int n;
    scanf("%d", &n);
    for(int i = 0; i < n; i++) {
        scanf("%d%d%d%d", &x[i][0], &x[i][1], &vx[i][0], &vx[i][1]);
    }
    for(int d = 0; d < 2; d++) {
        vector<L> lines;
        for(int i = 0; i < n; i++) {
            lines.push_back(L{P{0, x[i][d]}, P{1, vx[i][d]}});
        }
        uh[d] = compute_uh(lines);
        for(int i = 0; i < n; i++) {
            lines[i] = L{P{0, -x[i][d]}, P{1, -vx[i][d]}};
        }
        lh[d] = compute_uh(lines);
        for(auto & p : lh[d]) {
            p.y = -p.y;
        }
        /*printf("uh[%d] : \n", d);
        for(auto & p : uh[d]) {
            p.print();
        }
        printf("lh[%d] : \n", d);
        for(auto & p : lh[d]) {
            p.print();
        }*/
    }
    D ans = 1e50;
    auto update = [&](const D & x) {
        D u[2], d[2];
        D res = 1;
        for(int d = 0; d < 2; d++) {
            int p = lower_bound(uh[d].begin(), uh[d].end(), P{x, 0}, [&](const P & a, const P & b) {return a.x < b.x;}) - uh[d].begin();
            p = min(p, (int)uh[d].size() - 1);
            p = max(p, 1);
            D u = gety(uh[d][p - 1], uh[d][p], x);
            p = lower_bound(lh[d].begin(), lh[d].end(), P{x, 0}, [&](const P & a, const P & b) {return a.x < b.x;}) - lh[d].begin();
            p = min(p, (int)lh[d].size() - 1);
            p = max(p, 1);
            D l = gety(lh[d][p - 1], lh[d][p], x);
            res *= u - l;
        }
        ans = min(ans, res);
    };
    for(int d = 0; d < 2; d++) {
        for(auto & p : uh[d]) {
            update(p.x);
        }
        for(auto & p : lh[d]) {
            update(p.x);
        }
    }
    printf("%.12f\n", ans);
}