#pragma GCC optimize("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("avx,avx2,fma")

#include <bits/stdc++.h>

#define ll long long
#define ld  double
using namespace std;

const int N = 1e6 + 5, mod = 998244353;

vector<int> path, adj[N], s;

set<vector<int> > st;

int par[N];
int inCycle[N];

bool dfs(int u, int v, int par) {
    path.push_back(u);
    if(u == v)
        return true;
    for(auto to : adj[u]) {
        if(to == par) continue;
        if(dfs(to, v, u))
            return true;
    }
    path.pop_back();
    return false;
}

int id;

map<vector<int>, int> mp;


int dfs_col(int node, int par) {
    vector<int> cur;
    for(auto i: adj[node]) {
        if(i == par || inCycle[i]) continue;
//        cout << "EDGE " << node << ' ' << i << endl;
        cur.push_back(dfs_col(i, node));
    }
    sort(cur.begin(), cur.end());
    if(mp.find(cur) == mp.end()) mp[cur] = id++;
    return mp[cur];
}


void init() {
    id = 2;
    mp.clear();
    mp[vector<int>()] = 1;
    st.clear();

}

int findPar(int u) {
    if(par[u] == u) return u;
    return par[u] = findPar(par[u]);
}

bool sameSet(int u, int v) {
    return findPar(u) == findPar(v);
}

void join(int u, int v) {
    u = findPar(u);
    v = findPar(v);
    par[u] = v;
}

void initInBetween(int n) {
    path.clear();
    for(int i = 0; i <= n; i++) {
        adj[i].clear();
        inCycle[i] = 0;
    }
    s.clear();
    iota(par, par + n + 1, 0);
}


int min_cyc()
{
    int n = s.size();
    int res = 0;
    for (int l = 0; l < n; )
    {
        res = l;
        int r = l, p = l + 1;
        for (; r < n; ++r, ++p) /// If there is such string found, then its length wont exceed |s|
        {
            int c = (p < n) ? s[p] : s[p - n]; /// to avoid modulo
            if (s[r] > c) break;
            if (s[r] < c) r = l - 1;
        }
        l = max(r, l + p - r); /// just skip those (s2 = sx + sx + ... + sx + sy) cases
    }
    return res;
}


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);


    int tt;
    cin >> tt;
    while(tt--) {
        init();
        int n;
        cin >> n;
        for(int t = 0; t < n; t++) {
            int k;
            cin >> k;
            initInBetween(k);
            int from, to;
            for(int j = 0; j < k; j++) {
                int u, v;
                cin >> u >> v;
                adj[u].push_back(v);
                adj[v].push_back(u);
                if(sameSet(u, v)) {
                    from = u;
                    to = v;
                }
                join(u, v);
            }
            dfs(from, to, 0);
//            cout << "PATH\n";
            for(auto i: path) {
//                cout << i << ' ';
                inCycle[i] = 1;
            }
//            cout << '\n';

            for(auto i: path) {
                s.push_back(dfs_col(i, 0));
//                cout << s.back() << ' ';
            }
//            cout << endl;

            int idx = min_cyc();
            vector<int> lexoSmallest;
            for(int i = idx; i < (int) path.size(); i++) {
                lexoSmallest.push_back(s[i]);
            }
            for(int i = 0; i < idx; i++) {
                lexoSmallest.push_back(s[i]);
            }

            reverse(s.begin(), s.end());

            idx = min_cyc();

            vector<int> lex2;

            for(int i = idx; i < (int) path.size(); i++) {
                lex2.push_back(s[i]);
            }
            for(int i = 0; i < idx; i++) {
                lex2.push_back(s[i]);
            }

            st.insert(min(lexoSmallest, lex2));
//            for(auto i: lexoSmallest) cout << i << ' ';
//            cout << '\n';
        }
        cout << (int) st.size() << '\n';
        // cout << '\n';
    }





    return 0;
}

/*
 1
3
9 1 4 4 2 2 3 3 5 5 7 7 6 6 4 7 8 8 9
9 1 2 2 5 5 7 7 6 6 3 3 1 2 4 7 9 9 8
9 1 2 2 5 5 4 4 1 4 7 7 8 8 6 8 9 5 3
 */