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

const int MAXN = 100005;
int dists[MAXN], sizes[MAXN];
bool visited[MAXN];
vector<vector<int>> tree(MAXN);

void dfs_sizes(int cur, int prev) {
    sizes[cur] = 1;
    for (int nei : tree[cur]) {
        if (nei != prev && !visited[nei]) {
            dfs_sizes(nei, cur);
            sizes[cur] += sizes[nei];
        }
    }
}

void dfs(int start, int cur, int prev) {
    dists[cur] = (prev == -1 ? 0 : dists[prev] + 1);
    for (int nei : tree[cur]) {
        if (nei != prev && !visited[nei]) {
            dfs(start, nei, cur);
        }
    }
}

int find_centroid(int cur, int prev, int size) {
    for (int nei : tree[cur]) {
        if (nei != prev && !visited[nei]) {
            if (sizes[nei] * 2 > size) {
                return find_centroid(nei, cur, size);
            }
        }
    }
    return cur;
}

void build(int cur) {
    dfs_sizes(cur, -1);
    int centroid = find_centroid(cur, -1, sizes[cur]);
    dfs(centroid, centroid, -1);
    visited[centroid] = 1;
    for (int nei : tree[centroid]) {
        if (!visited[nei]) {
            build(nei);
        }
    }
}

int query(int u, int v) {
    cout << "? " << u + 1 << " " << v + 1 << endl;
    int ret;
    cin >> ret;
    return ret;
}

void answer(int x) {
    cout << "! " << x + 1 << endl;
}

void solve() {
    int n;
    cin >> n;
    
    for (int i = 0; i < n; i++) {
        tree[i].clear();
        visited[i] = false;
    }
    for (int i = 0; i < n; i++) {
        int u, v;
        cin >> u >> v;
        u--; v--;
        if (u >= 0) {
            tree[i].push_back(u);
            tree[u].push_back(i);
        }
        if (v >= 0) {
            tree[i].push_back(v);
            tree[v].push_back(i);
        }
    }
    
    dfs_sizes(0, -1);
    int cur = find_centroid(0, -1, sizes[0]);
    int res = -1;
    while (true) {
        vector<pair<int, int>> children;
        for (int nei : tree[cur]) {
            if (!visited[nei]) {
                children.emplace_back(-sizes[nei], nei);
            }
        }
        sort(children.begin(), children.end());
        if (children.empty()) {
            res = cur;
            break;
        } else if (children.size() == 1) {
            int ret = query(cur, children[0].second);
            res = (ret == 0 ? cur : children[0].second);
            break;
        } else {
            int one = children[0].second;
            int two = children[1].second;
            int ret = query(one, two);
            if (ret == 0) {
                visited[cur] = true;
                dfs_sizes(one, -1);
                cur = find_centroid(one, -1, sizes[one]);
            } else if (ret == 2) {
                visited[cur] = true;
                dfs_sizes(two, -1);
                cur = find_centroid(two, -1, sizes[two]);
            } else {
                if (children.size() == 2) {
                    res = cur;
                    break;
                }
                for (int nei : tree[cur]) {
                    if (nei != children[2].second) {
                        visited[nei] = 1;
                    }
                }
                dfs_sizes(cur, -1);
                cur = find_centroid(cur, -1, sizes[cur]);
            }
        }
    }
    answer(res);
}

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

    int t;
    cin >> t;
    while (t--) {
        solve();
    }
}