#include <fstream>
//#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;

ifstream cin("metrou4.in");
ofstream cout("metrou4.out");

const int MAXN = 150000;

struct Point {
    int x, y;
    int index;

    bool operator < (const Point &other) const {
        if (x == other.x)
            return y < other.y;
        return x < other.x;
    }
};

Point v[1 + MAXN];

struct Edge {
    int from, to;
    int cost;

    bool operator < (const Edge &other) const {
        return cost < other.cost;
    }
};

vector<Edge> edges;

void Rotate(int n) {
    for (int i = 1; i <= n; i++) {
        int x = v[i].x, y = v[i].y;
        v[i].x = -y;
        v[i].y = x;
    }
}

void Reflect(int n) {
    for (int i = 1; i <= n; i++)
        v[i].x *= -1;
}

int number[1 + MAXN];
pair<int, int> tree[1 + 4 * MAXN];

void Update(int node, int left, int right, int where, const Point &point) {
    if (!tree[node].second || tree[node].first < point.x + point.y)
        tree[node] = make_pair(point.x + point.y, point.index);
    if (left == right)
        return;
    int middle = (left + right) / 2;
    if (where <= middle)
        Update(2 * node, left, middle, where, point);
    else
        Update(2 * node + 1, middle + 1, right, where, point);
}

pair<int, int> Query(int node, int left, int right, int limit) {
    if (right <= limit)
        return tree[node];
    int middle = (left + right) / 2;
    if (limit <= middle)
        return Query(2 * node, left, middle, limit);
    pair<int, int> answer = Query(2 * node, left, middle, limit), temp = Query(2 * node + 1, middle + 1, right, limit);
    if (!answer.second || (temp.second && answer.first < temp.first))
        answer = temp;
    return answer;
}

void GetEdges(int n) {
    for (int i = 1; i <= n; i++)
        number[i] = v[i].y - v[i].x;
    sort(number + 1, number + n + 1);
    sort(v + 1, v + n + 1);
    int m = unique(number + 1, number + n + 1) - number - 1;
    for (int i = 1; i <= 4 * n; i++)
        tree[i] = make_pair(0, 0);
    for (int i = 1; i <= n; i++) {
        int where = lower_bound(number + 1, number + m + 1, v[i].y - v[i].x) - number;
        pair<int, int> answer = Query(1, 1, m, where);
        if (answer.second)
            edges.push_back({v[i].index, answer.second, v[i].x + v[i].y - answer.first});
        Update(1, 1, m, where, v[i]);
    }
}

int dad[1 + MAXN], h[1 + MAXN];

void Initialize(int n) {
    for (int i = 1; i <= n; i++) {
        dad[i] = i;
        h[i] = 1;
    }
}

int FindDad(int node) {
    if (dad[node] == node)
        return node;
    return dad[node] = FindDad(dad[node]);
}

void Join(int a, int b) {
    if (h[a] < h[b])
        dad[a] = b;
    else {
        dad[b] = a;
        if (h[a] == h[b])
            h[a]++;
    }
}

int main() {
    int tests;
    cin >> tests;
    for (int test = 1; test <= tests; test++) {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++) {
            cin >> v[i].x >> v[i].y;
            v[i].index = i;
        }
        edges.clear();
        for (int i = 1; i <= 2; i++) {
            for (int j = 1; j <= 4; j++) {
                GetEdges(n);
                Rotate(n);
            }
            Reflect(n);
        }
        Initialize(n);
        sort(edges.begin(), edges.end());
        long long answer = 0;
        for (auto &edge : edges)
            if (FindDad(edge.from) != FindDad(edge.to)) {
                answer += edge.cost;
                Join(FindDad(edge.from), FindDad(edge.to));
            }
        cout << answer << "\n";
    }
    return 0;
}