#include <bits/stdc++.h>
#define vis(x, y) vis[x][y - BOUNDS[x][0]]
#define g(x, y) g[x][y - BOUNDS[x][0]]
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    const int N = 17;
    const array LEN{1, 2, 3, 4, 13, 12, 11, 10, 9, 10, 11, 12, 13, 4, 3, 2, 1};
    const array<array<int, 2>, N> BOUNDS{{{0, 1}, {0, 2}, {0, 3}, {0, 4}, {-4, 9}, {-3, 9}, {-2, 9}, {-1, 9}, {0, 9}, {0, 10}, {0, 11}, {0, 12}, {0, 13}, {6, 10}, {7, 10}, {8, 10}, {9, 10}}};
    const array<array<int, 2>, 6> DELTAS{{{-1, 0}, {0, 1}, {1, 1}, {1, 0}, {0, -1}, {-1, -1}}};

    int t; cin >> t;
    
    while (t--) {
        int n; cin >> n;

        array<bitset<N>, N> g;
        for (int i = 0; i < n; ++i) {
            int x, y; cin >> x >> y;
            --x, --y;
            y += BOUNDS[x][0];

            g(x, y) = 1;
        }

        auto in = [&](int x, int y) {
            return 0 <= x && x < N && BOUNDS[x][0] <= y && y < BOUNDS[x][1];
        };

        auto bfs = [&](int sx, int sy) {
            array<bitset<N>, N> vis;
            queue<array<int, 2>> q;
            int cnt = 0;


            
            vis(sx, sy) = 1;
            q.push({sx, sy});

            // cerr << sx << ' ' << sy << '\n';

            while (!empty(q)) {
                auto [x, y] = q.front(); q.pop();
                ++cnt;

                // cerr << x << ' ' << y << '\n';

                for (auto& [dx, dy] : DELTAS) {
                    int pivot = 0, bx = x, by = y;
                    while (in(bx, by) && !g(bx, by)) {
                        ++pivot, bx += dx, by += dy;
                    }

                    if (!in(bx, by)) {
                        continue;
                    }

                    bool ok = true;
                    int nx = bx, ny = by;

                    for (int i = 0; i < pivot; ++i) {
                        nx += dx, ny += dy;

                        ok = ok && in(nx, ny) && !g(nx, ny);
                    }

                    if (ok && !vis(nx, ny)) {
                        vis(nx, ny) = 1;
                        q.push({nx, ny});
                    }
                }
            }

            return cnt;
        };

        int ans = 0;

        for (int x = 0; x < N; ++x) {
            for (int y = BOUNDS[x][0]; y < BOUNDS[x][1]; ++y) {
                if (g(x, y)) {
                    g(x, y) = 0;

                    ans += bfs(x, y) - 1;

                    g(x, y) = 1;
                }
            }
        }

        cout << ans << '\n';
    }
}