#include <bits/stdc++.h>
using namespace std;

const long long MAXC = 1000000005;

bool can_reach(long long l, long long r, long long target, long long v, long long dt) {
    if (target >= l && target <= r) {
        return true;
    }
    if (target < l) {
        return v * dt >= l - target;
    } else {
        return v * dt >= target - r;
    }
}

bool works(map<int, vector<int>> &events, long long v) {
    bool possible = true;
    long long prev = 0;
    long long l = 0;
    long long r = MAXC;
    long long fixed = -1;
    for (auto [t, pos] : events) {
        if (pos.size() > 2) {
            possible = false;
            break;
        }
        if (fixed == -1) {
            if (pos.size() == 1) {
                fixed = pos[0];
            } else {
                fixed = pos[0];
                l = pos[1];
                r = pos[1];
            }
        } else if (pos.size() == 2) {
            if ((can_reach(fixed, fixed, pos[0], v, t - prev) && can_reach(l, r, pos[1], v, t - prev)) ||
                (can_reach(fixed, fixed, pos[1], v, t - prev) && can_reach(l, r, pos[0], v, t - prev))) {
                fixed = pos[0];
                l = pos[1];
                r = pos[1];
            } else {
                possible = false;
                break;
            }
        } else {
            bool range_reach = can_reach(l, r, pos[0], v, t - prev);
            bool point_reach = can_reach(fixed, fixed, pos[0], v, t - prev);
            if (range_reach && !point_reach) {
                l = max((long long) 0, fixed - v * (t - prev));
                r = min(MAXC, fixed + v * (t - prev)); 
                fixed = pos[0];
            } else if (!range_reach && point_reach) {
                l = max((long long) 0, l - v * (t - prev));
                r = min(MAXC, r + v * (t - prev));
                fixed = pos[0];
            } else if (range_reach && point_reach) {
                long long newl = max((long long) 0, min(l - v * (t - prev), fixed - v * (t - prev)));
                long long newr = min(MAXC, max(r + v * (t - prev), fixed + v * (t - prev)));
                l = newl;
                r = newr;
                fixed = pos[0];
            } else {
                possible = false;
                break;
            }
        }
        prev = t;
    }
    return possible;
}

void solve() {
    int n;
    cin >> n;
    map<int, vector<int>> events;
    for (int i = 0; i < n; i++) {
        int t, c;
        cin >> t >> c;
        events[t].push_back(c);
    }

    long long l = 0;
    long long r = MAXC;
    long long res = -1;
    while (l <= r) {
        long long m = (l + r) / 2;
        if (works(events, m)) {
            res = m;
            r = m - 1;
        } else {
            l = m + 1;
        }
    }
    cout << res << "\n";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int t;
    cin >> t;
    while (t--) {
        solve();
    }
}