#include <bits/stdc++.h>

const int N = 1e5 + 50;
const int M = 1.3e6 + 50;

int siz[N];

std::mt19937 s(std::chrono::steady_clock::now().time_since_epoch().count());

template<const int mod>
struct hash_t
{
	int x = 0;
	inline int inc(int x, int y) const { x += y - mod; return x + (x >> 31 & mod); }
	inline int dec(int x, int y) const { x -= y; return x + (x >> 31 & mod); }
	inline int mul(int x, int y) const { return 1ll * x * y % mod; }
	hash_t() = default;
	hash_t(int v) : x(v) {}
	inline hash_t<mod> operator+(const hash_t<mod> &rhs) const
	{
		return hash_t(inc(x, rhs.x));
	}
	inline hash_t<mod> operator-(const hash_t<mod> &rhs) const 
	{
		return hash_t(dec(x, rhs.x));
	}
	inline hash_t<mod> operator*(const hash_t<mod> &rhs) const
	{
		return hash_t(mul(x, rhs.x));
	}
	inline bool operator==(const hash_t<mod> &rhs) const
	{
		return x == rhs.x;
	}
};

const int mod1 = 1e9 + 7, mod2 = 1e9 + 9;
struct number_t
{
	hash_t<mod1> v1;
	hash_t<mod2> v2;
	number_t() = default;
	number_t(int v) : v1(v), v2(v) {}
	number_t(hash_t<mod1> v1, hash_t<mod2> v2) : v1(v1), v2(v2) {}
	inline number_t operator+(const number_t &rhs) const
	{
		return number_t(v1 + rhs.v1, v2 + rhs.v2);
	}
	inline number_t operator-(const number_t &rhs) const
	{
		return number_t(v1 - rhs.v1, v2 - rhs.v2);
	}
	inline number_t operator*(const number_t &rhs) const
	{
		return number_t(v1 * rhs.v1, v2 * rhs.v2);
	}
	inline bool operator==(const number_t &rhs) const
	{
		return v1 == rhs.v1 && v2 == rhs.v2;
	}
} h[N];

int n, head[N], nxt[N << 1], ver[N << 1], cnt;
int prime[N << 1], tot;
bool np[M];

inline void init()
{
	for (int i = 2; i < M; ++i)
	{
		if (!np[i])
		{
			prime[++tot] = i;
		}
		for (int j = 1; j <= tot && i * prime[j] < M; ++j)
		{
			np[i * prime[j]] = true;
			if (i % prime[j] == 0) break;
		}
	}
	for (int i = 1; i <= tot; ++i) prime[i] = s() % 998244353;
}

inline void add(int u, int v)
{
	nxt[++cnt] = head[u];
	ver[cnt] = v;
	head[u] = cnt;
}

void dfs(int x, int f = 0)
{
	h[x] = 1; siz[x] = 1;
	for (int i = head[x]; i; i = nxt[i])
	{
		int y = ver[i];
		if (y != f)
		{
			dfs(y, x);
			siz[x] += siz[y];
			h[x] = h[x] + h[y] * prime[siz[y]];
		}
	}

}

template <int T>
struct fast_io
{
	char p[T], q[T], * p1, * p2, * q1, * q2;
	fast_io()
	{
		p1 = p2 = p;
		q1 = q, q2 = q + T;
	}
	inline char gc()
	{
		return p1 == p2 && (p2 = (p1 = p) + fread(p, 1, T, stdin), p1 == p2) ? EOF : *p1++;
	}
	inline void pc(char c)
	{
		if (q1 == q2) q2 = (q1 = q) + fwrite(q, 1, T, stdout);
		*q1++ = c;
	}
	~fast_io()
	{
		fwrite(q, 1, q1 - q, stdout);
	}
};
fast_io<1 << 18> io;
inline int read()
{
	int res = 0;
	char ch;
	do ch = io.gc(); while (ch < 48 || ch > 57);
	do res = res * 10 + ch - 48, ch = io.gc(); while (ch >= 48 && ch <= 57);
	return res;
}
inline void read(char *s)
{
	char ch;
	do ch = io.gc(); while (!isalpha(ch));
	do *s++ = ch, ch = io.gc(); while (isalpha(ch));
	*s = 0;
}
inline int rb()
{
	char ch;
	do ch = io.gc(); while (ch < 48 || ch > 57);
	return ch - 48;
}
inline int rn()
{
	char ch; int c = 0;
	do ch = io.gc(); while (ch != '?');
	do ++c, ch = io.gc(); while (ch == '?');
	return c;
}
inline void put(int x)
{
	if (x < 0) io.pc('-'), x = -x;
	if (x >= 10) put(x / 10);
	io.pc(48 + x % 10);
}
inline void output(int x, char ch = ' ')
{
	put(x);
	io.pc(ch);
}
inline void outputs(const char *s)
{
	while (*s) io.pc(*s++);
	io.pc('\n');
}


inline number_t getHashValue(int n)
{
	cnt = 0;
	memset(head, 0, (n + 2) << 2);
	for (int i = 1; i < n; ++i)
	{
		int x = read(), y = read();
		add(x, y), add(y, x);
	}
	dfs(1);
	return h[1];
}
int main()
{
	init();
	int T = read();
	while (T--)
	{
		n = read();
		auto v1 = getHashValue(n);
		auto v2 = getHashValue(n);
		outputs(v1 == v2 ? "Isomorphism" : "No");	
	}
	return 0;
}