#include <bits/stdc++.h>   using namespace std;   using LL = long long;   constexpr int maxn = 2200;   LL a[maxn * 2], b[maxn * 2];   using PII = pair<int, int>;   constexpr int inf = 1000000000;   struct SSPA {     struct Edge {       int u, v, f, c;     };     int n, s, t;     vector<Edge> edges;     vector<vector<int>> adj;     vector<int> h, d, p, done;     SSPA(int n, int s, int t) : n(n), s(s), t(t) {       adj.resize(n);       h.resize(n);       d.resize(n);       p.resize(n);       done.resize(n);     }     void add(int u, int v, int f, int c) {       adj[u].push_back(edges.size());       edges.push_back({u, v, f, c});       adj[v].push_back(edges.size());       edges.push_back({v, u, 0, -c});     }     bool dijkstra() {       fill(d.begin(), d.end(), inf);       fill(p.begin(), p.end(), -1);       fill(done.begin(), done.end(), 0);       priority_queue<PII, vector<PII>, greater<PII>> q;       q.push({d[s] = 0, s});       while (not q.empty()) {         int u = q.top().second;         q.pop();         if (done[u]) continue;         done[u] = 1;         for (int i : adj[u]) {           if (auto& e = edges[i]; e.f and d[e.v] > d[e.u] + e.c + h[u] - h[e.v]) {             p[e.v] = i;             q.push({d[e.v] = d[e.u] + e.c + h[u] - h[e.v], e.v});           }         }       }       return ~p[t];     }     int min_cost_flow() {       int flow = 0, cost = 0;       while (dijkstra()) {         for (int i = 0; i < n; i += 1) h[i] += d[i];         int f = inf;         for (int u = t; u != s; u = edges[p[u]].u) f = min(f, edges[p[u]].f);         flow += f;         cost += f * h[t];         for (int u = t; u != s; u = edges[p[u]].u) {           edges[p[u]].f -= f;           edges[p[u] ^ 1].f += f;         }       }       return cost;     }   };   int main() {     ios::sync_with_stdio(false);     cin.tie(nullptr);     cout.tie(nullptr);     int n;     cin >> n;     for (int i = 0; i < 2 * n; i += 1) cin >> a[i] >> b[i];     LL L = 0, R = 1000000000 + 1;     vector<int> u;     for (int i = 0; i < 2 * n; i += 1) u.push_back(i);     sort(u.begin(), u.end(), [&](const int& x, const int& y) {       if (b[x] != b[y]) return b[x] < b[y];       return a[x] > a[y];     });     while (L < R) {       LL M = (L + R) >> 1;       vector<LL> v, w;       LL m = 0;       for (int i : u) {         m = max(m, a[i] * M + b[i]);         if (i < n)           v.push_back(m);         else           w.push_back(a[i] * M + b[i]);       }       int ok = 1;       sort(w.begin(), w.end());       for (int i = 0; i < n; i += 1) ok &= v[i] >= w[i];       if (ok)         R = M;       else         L = M + 1;     }     if (L == 1000000000 + 1) {       cout <<  -1 ;       return 0;     }     cout << L <<    ;     int s = 0, t = 8 * n + 1;     SSPA SSPA(t + 1, s, t);     for (int i = 0; i < n; i += 1) SSPA.add(s, i + 1, 1, 0);     for (int i = n; i < 2 * n; i += 1) SSPA.add(4 * n + i + 1, t, 1, 0);     for (int i = 0; i < 2 * n; i += 1) {       SSPA.add(2 * n + i + 1, i + 1, inf, 0);       SSPA.add(i + 1, 2 * n + i + 1, inf, 1);       SSPA.add(6 * n + i + 1, 4 * n + i + 1, inf, 0);       SSPA.add(4 * n + i + 1, 6 * n + i + 1, inf, 1);       SSPA.add(i + 1, 4 * n + i + 1, inf, 0);     }     for (int i = 1; i < 2 * n; i += 1) {       SSPA.add(2 * n + u[i] + 1, 2 * n + u[i - 1] + 1, inf, 0);       if (b[u[i]] == b[u[i - 1]])         SSPA.add(2 * n + u[i - 1] + 1, 2 * n + u[i] + 1, inf, 0);     }     sort(u.begin(), u.end(), [&](const int& x, const int& y) {       return a[x] * L + b[x] < a[y] * L + b[y];     });     for (int i = 1; i < 2 * n; i += 1) {       SSPA.add(6 * n + u[i] + 1, 6 * n + u[i - 1] + 1, inf, 0);       if (a[u[i]] * L + b[u[i]] == a[u[i - 1]] * L + b[u[i - 1]])         SSPA.add(6 * n + u[i - 1] + 1, 6 * n + u[i] + 1, inf, 0);     }     cout << SSPA.min_cost_flow();     return 0;   }   