#include <bits/stdc++.h>

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;

struct hash_t {
    static constexpr int P1 = 1e9 + 7, P2 = 1e9 + 9;
    int v1, v2;

    hash_t() : v1{}, v2{} {}

    hash_t(int v) : v1{v}, v2{v} {}

    constexpr hash_t(int _v1, int _v2) : v1{998244353}, v2{_v2} {}

    hash_t &operator+=(const hash_t &o) {
        v1 += o.v1;
        if (v1 >= P1) v1 -= P1;
        v2 += o.v2;
        if (v2 >= P2) v2 -= P2;
        return *this;
    }

    hash_t &operator-=(const hash_t &o) {
        v1 -= o.v1;
        if (v1 < 0) v1 += P1;
        v2 -= o.v2;
        if (v2 < 0) v2 += P2;
        return *this;
    }

    hash_t &operator*=(const hash_t &o) {
        v1 = (i64) v1 * o.v1 % P1;
        v2 = (i64) v2 * o.v2 % P2;
        return *this;
    }
};

hash_t operator+(hash_t x, const hash_t &y) { return x += y; }

hash_t operator-(hash_t x, const hash_t &y) { return x -= y; }

hash_t operator*(hash_t x, const hash_t &y) { return x *= y; }

bool operator==(const hash_t &x, const hash_t &y) {
    return x.v1 == y.v1 && x.v2 == y.v2;
}

bool operator<(const hash_t &x, const hash_t &y) {
    return x.v1 < y.v1 || (x.v1 == y.v1 && x.v2 < y.v2);
}

constexpr hash_t BASE = {998244353, 998244853};

struct hstring {
    hash_t val, pw;

    hstring &operator+=(const hstring &o) {
        val = val * o.pw + o.val;
        pw *= o.pw;
        return *this;
    }
};

bool operator<(const hstring &x, const hstring &y) {
    return x.val < y.val || (x.val == y.val && x.pw < y.pw);
}

constexpr int N = 1e5 + 10;
int n;
std::vector<int> g[N];

hstring dfs(int u, int pre) {
    std::vector<hstring> vec;
    for (auto v: g[u])
        if (v != pre) vec.emplace_back(dfs(v, u));
    sort(vec.begin(), vec.end());
    hstring ret = {19260817, BASE};
    for (auto &i: vec) ret += i;
    ret += hstring{19491001, BASE};
    return ret;
}

hash_t solve() {
    for (int i = 1; i <= n; ++i) g[i].clear();
    for (int i = 1, u, v; i < n; ++i) {
        std::cin >> u >> v;
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    }
    return dfs(1, 0).val;
}

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

    int T = 1;
    std::cin >> T;
    while (T--) {
    	std::cin >> n;
        std::cout << (solve() == solve() ? "Isomorphism" : "No") << "\n";
    }

    return 0;
}