#include <bits/stdc++.h>

using namespace std;

const int MAXN = (int) 1e3 + 5;
const int MAXL = (int) 1e6 + 5;

const int INF = 0x3f3f3f3f;

int dp[MAXN][4];
int pos[MAXN][4];

int cnt[MAXN][MAXN][4];

namespace BIT {
    const int LIM = (int) 1e6;
    
    int c[MAXL];
    
    void clear() {
        memset(c, 0, sizeof c);
    }
    
    int lowbit(int x) {
        return x & -x;
    }
    
    void add(int a, int x) {
        for (int i = a; i <= LIM; i += lowbit(i)) {
            c[i] += x;
        }
    }
    
    int query(int a) {
        int res = 0;
        for (int i = a; i > 0; i -= lowbit(i)) {
            res += c[i];
        }
        return res;
    }
}

int main() {
    int case_cnt; scanf("%d", &case_cnt);
    while (case_cnt--) {
        int n; scanf("%d", &n);
        
        for (int i = 1; i <= n; ++i) {
            int x, y; scanf("%d%d", &x, &y);
            pos[i][0] = x;
            pos[i][1] = y;
            pos[i][2] = x + 1;
            pos[i][3] = y - 1;
        }
        
        BIT::clear();
        
        for (int i = 1; i <= n; ++i) {
            BIT::add(pos[i][0], 1);
            BIT::add(pos[i][1] + 1, -1);
            
            for (int j = 1; j <= n; ++j) {
                for (int t = 0; t < 4; ++t) {
                    cnt[i][j][t] = BIT::query(pos[j][t]);
                }
            }
        }
        
        int ans = INF;
        
        for (int i = 1; i <= n; ++i) {
            for (int t = 0; t < 4; ++t) {
                if (cnt[i][i][t] == i) {
                    dp[i][t] = 0;
                } else {
                    dp[i][t] = INF;
                    if (pos[i][0] == pos[i][1] && t >= 2) continue;
                    for (int j = 0; j < i; ++j) {
                        for (int tt = 0; tt < 4; ++tt) if (cnt[i][i][t] - cnt[j][i][t] == i - j || cnt[i][j][tt] - cnt[j][j][tt] == i - j) {
                            dp[i][t] = min(dp[i][t], dp[j][tt] + (abs(pos[i][t] - pos[j][tt]) + 1) / 2);
                        }
                    }
                }
                if (cnt[n][i][t] - cnt[i][i][t] == n - i) {
                    ans = min(ans, dp[i][t]);
                }
            }
        }
        
        printf("%d\n", ans);
    }
    
    return 0;
}