/*
        File: icpc-mock-131124-E-B_main.cpp
        Date and Time Created: 2024-11-13 18:24:28
        Author: Rahul M. Navneeth
*/

/* ----------------- HEADER FILES ----------------- */

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

/* ----------------- NAMESPACE ----------------- */

using namespace std;
using namespace chrono;
using namespace __gnu_pbds;

/* ----------------- TEMPLATES ------------------ */

/* clang-format off */

// MACROS
#define fast_io ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define io freopen("./input.txt", "r", stdin); freopen("./output.txt", "w", stdout); freopen("./output.txt", "w", stderr);

// TYPEDEF
typedef long long ll;
typedef unsigned long long ull;
typedef long double lld;
typedef tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> pbds; // POLICY BASED DS

// SHORTCUTS
#define ar array
#define pb push_back
#define pob pop_back
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define F first
#define S second
#define UNIQUE_SORT(v) sort(all(v)); v.erase(unique(all(v)), v.end())

// FUNCTIONS
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void swap(int &x, int &y) { int temp = x; x = y; y = temp; }
ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) { ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m; }
bool revsort(ll a, ll b) {return a > b;}
ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0) n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} //O(sqrt(N))
ll getRandomNumber(ll l, ll r) {return uniform_int_distribution<ll>(l, r)(rng);} 
vector<ll> sieve(int n) {int*arr = new int[n + 1](); vector<ll> vect; for (int i = 2; i <= n; i++)if (arr[i] == 0) {vect.push_back(i); for (int j = 2 * i; j <= n; j += i)arr[j] = 1;} return vect;}
ll modpow(ll a, ll b, ll MOD) { ll res = 1; while(b > 0) { if(b & 1) { res = (res * a) % MOD; } b = b >> 1; a = (a*a) % MOD; } return res; }
void extendgcd(ll a, ll b, ll *v) { if (b == 0) { v[0] = 1; v[1] = 0; v[2] = a; return; }
extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return; } // PASS AN ARRY OF SIZE1 3
ll mminv(ll a, ll b) { ll arr[3]; extendgcd(a, b, arr); return arr[0]; } // FOR NON PRIME B
ll mminvprime(ll a, ll b) { return modpow(a, b - 2, b); }
ll mod_add(ll a, ll b, ll m) { a = a % m; b = b % m; return (((a + b) % m) + m) % m; }
ll mod_mul(ll a, ll b, ll m) { a = a % m; b = b % m; return (((a * b) % m) + m) % m; }
ll mod_sub(ll a, ll b, ll m) { a = a % m; b = b % m; return (((a - b) % m) + m) % m; }
ll mod_div(ll a, ll b, ll m) { a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m; } // ONLY FOR PRIME M
void precision(int a) { cout << setprecision(a) << fixed; }

// CONSTANTS
const float PI = 3.141592653589793238462;
const int MOD = 1e9 + 7;
const int mxn = 1e7;
const int LOG = 30;

/* --------------------- CODE BEGINS ---------------------- */

struct point2d {
    double x, y;
    point2d() {}
    point2d(double x, double y): x(x), y(y) {}
    point2d& operator+=(const point2d &t) {
        x += t.x;
        y += t.y;
        return *this;
    }
    point2d& operator-=(const point2d &t) {
        x -= t.x;
        y -= t.y;
        return *this;
    }
    point2d& operator*=(double t) {
        x *= t;
        y *= t;
        return *this;
    }
    point2d& operator/=(double t) {
        x /= t;
        y /= t;
        return *this;
    }
    point2d operator+(const point2d &t) const {
        return point2d(*this) += t;
    }
    point2d operator-(const point2d &t) const {
        return point2d(*this) -= t;
    }
    point2d operator*(double t) const {
        return point2d(*this) *= t;
    }
    point2d operator/(double t) const {
        return point2d(*this) /= t;
    }
};

point2d operator*(double a, point2d b) {
    return b * a;
}

void solve() {
    ll N; cin >> N;
    ar<point2d, 2> a[N];
    for (ll i = 0; i < N; i++) cin >> a[i][0].x >> a[i][0].y >> a[i][1].x >> a[i][1].y;
    
    double mn = numeric_limits<double>::infinity();
    bool b = 0;

    for (ll i = 0; i < N; i++) {
        point2d p1 = a[i][0], p2 = a[i][1];
        
        if (p1.x * p2.x < 0) {
            double y_intersection = p1.y + (p2.y - p1.y) * (-p1.x) / (p2.x - p1.x);
            if (y_intersection > 0) {
                double d = y_intersection;
                if (d < mn) {
                    mn = d;
                    b = 1;
                }
            }
        } else if (p1.x == 0 && p1.y > 0) {
            double d = p1.y;
            if (d < mn) {
                mn = d;
                b = 1;
            }
        } else if (p2.x == 0 && p2.y > 0) {
            double d = p2.y;
            if (d < mn) {
                mn = d;
                b = true;
            }
        }
    }
    
    if (b) {
		precision(10);
		cout << mn << "\n";
    } else {
		cout << -1.0 << "\n";
    }
}

/*---------------------- MAIN DRIVER ------------------------*/

// MAIN
int32_t main() {
  fast_io
  #ifndef ONLINE_JUDGE
    io;
  #endif
  high_resolution_clock::time_point start, end;
  #ifndef ONLINE_JUDGE
    start = chrono::high_resolution_clock::now();
  #endif
  int t = 1;
  int i = 1;
  // cin >> t;
  while (i <= t) {
  	#ifndef ONLINE_JUDGE
		cout << "TESTCASE #" << i << "\n";
	#endif
	i++;
    solve();
  }
  #ifndef ONLINE_JUDGE
    end = chrono::high_resolution_clock::now();
    auto duration = chrono::duration_cast<chrono::milliseconds>(end - start);
    cout << "-------------\nRUNTIME: " << duration.count() << " ms\n";
  #endif
  return 0;
}

/* clang-format on */