#include <bits/stdc++.h>
using namespace std;

// ================================================================= UF Library
class UnionFind {
public:
	vector<int> par;

	void init(int sz) {
		par.resize(sz, -1);
	}

	int root(int pos) {
		if (par[pos] == -1) return pos;
		par[pos] = root(par[pos]);
		return par[pos];
	}

	void unite(int u, int v) {
		u = root(u);
		v = root(v);
		if (u != v) par[u] = v;
	}

	bool same(int u, int v) {
		if (root(u) == root(v)) return true;
		return false;
	}
};

// ================================================================= Base Function
long long mod1 = 900000011LL;
long long mod2 = 998244353LL;
long long mod3 = 2147483647LL;
long long pow1[1 << 22];
long long pow2[1 << 22];
long long pow3[1 << 22];
long long Rand[1 << 22];

struct Hash {
	long long v1, v2, v3;
};

bool isprime(long long x) {
	for (long long i = 2; i * i <= x; i++) {
		if (x % i == 0) return false;
	}
	return true;
}

long long get_prime(long long l, long long r) {
	while (true) {
		long long x = (rand() % 32768) * 32768 + (rand() % 32768);
		long long y = x % (r - l + 1) + l;
		if (isprime(y) == true) return y;
	}
}

bool operator==(const Hash &a1, const Hash &a2) {
	if (a1.v1 != a2.v1) return false;
	if (a1.v2 != a2.v2) return false;
	if (a1.v3 != a2.v3) return false;
	return true;
}

bool operator<(const Hash &a1, const Hash &a2) {
	if (a1.v1 < a2.v1) return true;
	if (a1.v1 > a2.v1) return false;
	if (a1.v2 < a2.v2) return true;
	if (a1.v2 > a2.v2) return false;
	if (a1.v3 < a2.v3) return true;
	return false;
}

void Initialize() {
	mod1 = get_prime( 900000000LL, 1000000000LL);
	mod2 = get_prime(1000000000LL, 1100000000LL);
	mod3 = get_prime(1100000000LL, 1200000000LL);
	pow1[0] = 1; for (int i = 1; i <= 2000000; i++) pow1[i] = (222222223LL * pow1[i - 1]) % mod1;
	pow2[0] = 1; for (int i = 1; i <= 2000000; i++) pow2[i] = (222222223LL * pow2[i - 1]) % mod2;
	pow3[0] = 1; for (int i = 1; i <= 2000000; i++) pow3[i] = (222222223LL * pow3[i - 1]) % mod3;
	map<long long, long long> Map;
	long long x = 869120;
	for (int i = 0; i <= 2000000; i++) {
		while (true) {
			long long r = (rand() % 32768) * 32768 + (rand() % 32768);
			long long v = (r + x) % mod1;
			if (Map[v] == 0) {
				Rand[i] = v;
				Map[v] = 1;
				x = (x * 3LL) % mod1;
				break;
			}
		}
	}
}

Hash Apply(Hash a1, Hash a2) {
	Hash a3;
	a3.v1 = (222222223LL * a1.v1 + a2.v1) % mod1;
	a3.v2 = (222222223LL * a1.v2 + a2.v2) % mod2;
	a3.v3 = (222222223LL * a1.v3 + a2.v3) % mod3;
	return a3;
}

Hash CycleHash(vector<Hash> vec) {
	Hash minv = {mod1 - 1, mod2 - 1, mod3 - 1};
	int N = vec.size();

	// Get Hash
	for (int t = 0; t < 2; t++) {
		vector<Hash> cur(2 * N + 1);
		cur[0] = Hash{0LL, 0LL, 0LL};
		for (int i = 0; i < 2 * N; i++) cur[i + 1] = Apply(cur[i], vec[i % N]);
		for (int i = 0; i < N; i++) {
			Hash p;
			p.v1 = (cur[N + i].v1 - cur[i].v1 * pow1[N] + mod1 * mod1) % mod1;
			p.v2 = (cur[N + i].v2 - cur[i].v2 * pow2[N] + mod2 * mod2) % mod2;
			p.v3 = (cur[N + i].v3 - cur[i].v3 * pow3[N] + mod3 * mod3) % mod3;
			minv = min(minv, p);
		}
		reverse(vec.begin(), vec.end());
	}
	return minv;
}

Hash GraphHash(int pos, int pre, vector<vector<int>> &G) {
	vector<Hash> V;
	for (int to : G[pos]) {
		if (to == pre) continue;
		Hash ret = GraphHash(to, pos, G);
		V.push_back(ret);
	}
	sort(V.begin(), V.end());
	Hash p = {2024LL, 2024LL, 2024LL};
	for (int i = 0; i < (int)V.size(); i++) p.v1 = (277277277LL * (p.v1 * p.v1 % mod1) + V[i].v1 * Rand[i]) % mod1;
	for (int i = 0; i < (int)V.size(); i++) p.v2 = (277277277LL * (p.v2 * p.v2 % mod2) + V[i].v2 * Rand[i]) % mod2;
	for (int i = 0; i < (int)V.size(); i++) p.v3 = (277277277LL * (p.v3 * p.v3 % mod3) + V[i].v3 * Rand[i]) % mod3;
	return p;
}


// ================================================================= Others
void dfs(int pos, int goal, int pre, vector<int> &Current, vector<int> &Answer, vector<vector<int>> &G) {
	if (pos == goal) {
		Answer = Current;
		return;
	}
	for (int to : G[pos]) {
		if (to == pre) continue;
		Current.push_back(to);
		dfs(to, goal, pos, Current, Answer, G);
		Current.pop_back();
	}
}

pair<int, Hash> GetTotalHash(int N, vector<pair<int, int>> Edges) {
	UnionFind UF; UF.init(N + 1);
	vector<vector<int>> G(N, vector<int>(0, 0));
	vector<vector<int>> H(N, vector<int>(0, 0));
	vector<int> Path;
	vector<bool> IsCycle(N, false);

	// Get Cycle
	for (int i = 0; i < (int)Edges.size(); i++) {
		if (UF.same(Edges[i].first, Edges[i].second) == true) {
			vector<int> tmp = {Edges[i].first};
			dfs(Edges[i].first, Edges[i].second, -1, tmp, Path, G);
		}
		else {
			UF.unite(Edges[i].first, Edges[i].second);
			G[Edges[i].first].push_back(Edges[i].second);
			G[Edges[i].second].push_back(Edges[i].first);
		}
	}

	// Get New Graph
	for (int idx : Path) IsCycle[idx] = true;
	for (pair<int, int> e : Edges) {
		if (IsCycle[e.first] == true && IsCycle[e.second] == true) continue;
		H[e.first].push_back(e.second);
		H[e.second].push_back(e.first);
	}

	// Get Hash
	vector<Hash> E(Path.size());
	for (int i = 0; i < (int)Path.size(); i++) {
		E[i] = GraphHash(Path[i], -1, H);
	}
	return make_pair(Path.size(), CycleHash(E));
}

int main() {
	int T; scanf("%d", &T);
	Initialize();
	for (int t = 1; t <= T; t++) {
		int N; scanf("%d", &N);
		vector<vector<pair<int, int>>> Graph(N);

		// Input Graph
		for (int i = 0; i < N; i++) {
			int K; scanf("%d", &K);
			Graph[i].resize(K, make_pair(0, 0));
			for (int j = 0; j < K; j++) {
				scanf("%d%d", &Graph[i][j].first, &Graph[i][j].second);
				Graph[i][j].first -= 1;
				Graph[i][j].second -= 1;
			}
		}

		// Get Hash
		vector<tuple<int, int, Hash>> Answer(N);
		for (int i = 0; i < N; i++) {
			pair<int, Hash> v = GetTotalHash(Graph[i].size(), Graph[i]);
			Answer[i] = make_tuple(Graph[i].size(), v.first, v.second);
		}
		sort(Answer.begin(), Answer.end());
		Answer.erase(unique(Answer.begin(), Answer.end()), Answer.end());

		// Output
		printf("%d\n", (int)Answer.size());
	}
	return 0;
}