#include<iostream>
#include<cstring>
#include<vector>
#include<array>
#include<set>
#include<queue>
using namespace std;
using LL = long long;

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    const int delta[] = {0, 4, 4, 4, 4, 0, 1, 2, 3, 4, 4, 4, 4, 4, 9, 10, 11, 12};
    const pair<int, int> valid[] = {{}, {5, 5}, {5, 6}, {5, 7}, {5, 8},
                                        {1, 13}, {2, 13}, {3, 13}, {4, 13},
                                        {5, 13}, {5, 14}, {5, 15}, {5, 16}, {5, 17},
                                        {10, 13}, {11, 13}, {12, 13}, {13, 13}};

    int T;
    cin >> T;
    while(T--){
        int n;
        cin >> n;
        vector<pair<int, int> > p(n);
        set<pair<int, int> > occupy;
        for(int i = 0; i < n; i++){
            int x, y;
            cin >> x >> y;
            y += delta[x];
            p[i] = {x, y};
            occupy.insert(p[i]);
        }
        
        int ans = 0;
        for(int i = 0; i < n; i++){
            set<pair<int, int> > s;
            queue<pair<int, int> > q;
            q.push(p[i]);
            while(!q.empty()){
                auto [x1, y1] = q.front();
                q.pop();
                for(int j = 0; j < n; j++){
                    if (i == j) continue;
                    auto [x2, y2] = p[j];
                    if (x1 != x2 && y1 != y2 && y1 - x1 != y2 - x2) continue;
                    int x = 2 * x2 - x1;
                    int y = 2 * y2 - y1;
                    if (x <= 0 || x >= 17) continue;
                    if (y < valid[x].first || y > valid[x].second) continue;
                    if (occupy.contains({x, y})) continue;
                    bool ok = true;
                    if (x1 == x2){
                        auto [mn, mx] = minmax(y1, y2);
                        for(int k = mn + 1; k <= mx - 1; k++){
                            if (occupy.contains({x1, k})){
                                ok = false;
                                break;
                            }
                        }
                    }
                    else if (y1 == y2){
                        auto [mn, mx] = minmax(x1, x2);
                        for(int k = mn + 1; k <= mx - 1; k++){
                            if (occupy.contains({k, y1})){
                                ok = false;
                                break;
                            }
                        }
                    }
                    else{
                        auto [mn1, mx1] = minmax(x1, x2);
                        auto [mn2, mx2] = minmax(y1, y2);
                        for(int k1 = mn1 + 1, k2 = mn2 + 1; k1 <= mx1 - 1; k1++, k2++){
                            if (occupy.contains({k1, k2})){
                                ok = false;
                                break;
                            }
                        }
                    }
                    if (!ok) continue;
                    if (!s.contains({x, y})){
                        s.insert({x, y});
                        q.push({x, y});
                    }
                }
            }
            ans += (int)s.size();
        }
        cout << ans << '\n';
    }

}