#include <bits/stdc++.h>

using i64 = long long;

constexpr i64 inf = 1e18;

template <typename T, typename Cmp = std::less<T>>
struct RMQ {
    const Cmp cmp{};
    int n;
    std::vector<std::vector<T>> a;
    RMQ() = default;
    RMQ(const std::vector<T> &v) {
        init(v);
    }
    RMQ(const std::vector<T> &v, const Cmp &cmp_) : cmp{cmp_} {
        init(v);
    }
    void init(const std::vector<T> &ini) {
        n = int(ini.size());
        int lg = std::__lg(n);
        a.assign(lg + 1, std::vector<T>(n));
        a[0] = ini;
        for (int i = 0; i < lg; ++i) {
            for (int j = 0; j <= n - (2 << i); ++j) {
                a[i + 1][j] = std::min(a[i][j], a[i][j + (1 << i)], cmp);
            }
        }
    }
    T operator()(int l, int r) const {
        int k = std::__lg(r - l);
        return std::min(a[k][l], a[k][r - (1 << k)], cmp);
    }
};

void solve() {
    int n;
    std::cin >> n;

    std::vector<i64> x(n), y(n);
    for (int i = 0; i < n; ++i) {
        std::cin >> x[i] >> y[i];
    }
    x.push_back(0);
    y.push_back(0);
    ++n;

    auto get = [&](const std::vector<int> &id) {
        std::vector<i64> v;
        for (auto i : id) {
            v.push_back(std::abs(x[i]));
        }
        std::sort(v.begin(), v.end());
        v.erase(std::unique(v.begin(), v.end()), v.end());

        std::vector<i64> l(v.size() + 1), r(v.size() + 1);
        for (auto i : id) {
            int nx = std::lower_bound(v.begin(), v.end(), std::abs(x[i])) - v.begin();
            l[nx] = std::min(l[nx], y[i]);
            r[nx] = std::max(r[nx], y[i]);
        }
        for (int i = int(v.size()) - 1; i >= 0; --i) {
            l[i] = std::min(l[i], l[i + 1]);
            r[i] = std::max(r[i], r[i + 1]);
        }
        return std::make_tuple(v, l, r);
    };
    std::vector<int> pos, neg{n - 1};
    for (int i = 0; i < n; ++i) {
        if (x[i] >= 0) {
            pos.push_back(i);
        } else {
            neg.push_back(i);
        }
    }
    auto [pv, pl, pr] = get(pos);
    auto [nv, nl, nr] = get(neg);

    auto calc = [&](int s, i64 v, i64 l, i64 r) {
        return (s / 4 % 2 + 1) * v + s / 2 % 2 * (1 + s / 8) * r - s % 2 * (2 - s / 8) * l;
    };
    std::vector<i64> f(nv.size());
    std::array<RMQ<i64>, 16> rmq;
    for (int s = 0; s < 16; ++s) {
        for (int i = 0; i < int(nv.size()); ++i) {
            f[i] = calc(s, nv[i], nl[i + 1], nr[i + 1]);
        }
        rmq[s].init(f);
    }

    i64 ans = inf;
    for (int i = 0, jl = 0, jr = 0, kl = 0, kr = 0; i < int(pv.size()); ++i) {
        while (jl < int(nv.size()) && pl[i + 1] > nl[jl + 1]) {
            ++jl;
        }
        while (kl < int(nv.size()) && pl[i + 1] >= nl[kl + 1]) {
            ++kl;
        }
        while (jr < int(nv.size()) && pr[i + 1] < nr[jr + 1]) {
            ++jr;
        }
        while (kr < int(nv.size()) && pr[i + 1] <= nr[kr + 1]) {
            ++kr;
        }
        for (int s = 0; s < 16; ++s) {
            int ql = std::max(s % 2 ? 0 : jl, s / 2 % 2 ? 0 : jr);
            int qr = std::min(s % 2 ? kl : int(nv.size()), s / 2 % 2 ? kr : int(nv.size()));
            if (ql < qr) {
                i64 res = rmq[s](ql, qr) + calc(s ^ 7, pv[i], pl[i + 1], pr[i + 1]);
                ans = std::min(ans, res);
            }
        }
    }

    std::cout << ans << "\n";
}

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    int t;
    std::cin >> t;

    while (t--) {
        solve();
    }

    return 0;
}