#include <bits/stdc++.h>

#define int long long

void solve()
{
    int n;
    std::cin >> n;
    std::vector<std::vector<int>> g(n + 1);
    for (int i = 1; i <= n; ++i)
    {
        int x, y;
        std::cin >> x >> y;
        if (x)
        {
            g[i].push_back(x);
            g[x].push_back(i);
        }
        if (y)
        {
            g[i].push_back(y);
            g[y].push_back(i);
        }
    }
    std::vector<int> vis(n + 1, 0);
    std::vector<int> siz(n + 1, 0);

    auto query = [&](int x, int y) -> int
    {
        std::cout << "? " << x << ' ' << y << std::endl;
        int ans;
        std::cin >> ans;
        return ans;
    };

    auto dfsSize = [&](auto dfsSize, int u, int fa) -> void
    {
        siz[u] = 1;
        for (auto v : g[u])
        {
            if (v != fa and !vis[v])
            {
                dfsSize(dfsSize, v, u);
                siz[u] += siz[v];
            }
        }
    };
    auto getroot = [&](auto getroot, int u, int fa, int Size) -> int
    {
        for (auto v : g[u])
        {
            if (v != fa and !vis[v] and 2 * siz[v] > Size)
            {
                return getroot(getroot, v, u, Size);
            }
        }
        return u;
    };
    int num = std::__lg(n);
    int now = 1;
    int root;
    while (num--)
    {
        dfsSize(dfsSize, now, 0);
        if (siz[now] == 1)
        {
            std::cout << "! " << now << std::endl;
            return;
        }
        root = getroot(getroot, now, 0, siz[now]);
        std::vector<int> cur;
        for (auto v : g[root])
        {
            if (!vis[v])
            {
                cur.push_back(v);
            }
        }
        if (cur.size() == 1)
        {
            int res = query(root, cur[0]);
            std::cout << "! " << (res ? cur[0] : root) << std::endl;
            return;
        }
        dfsSize(dfsSize, root, 0);
        std::sort(begin(cur), end(cur), [&](int i, int j)
                  { return siz[i] > siz[j]; });
        int res = query(cur[0], cur[1]);
        if (!res)
        {
            vis[root] = 1;

            now = cur[0];
        }
        else if (res == 2)
        {
            vis[root] = 1;

            now = cur[1];
        }
        else
        {
            now = root;
            vis[cur[0]] = vis[cur[1]] = 1;
        }
    }
    std::cout << "! " << now << std::endl;
}
signed main()
{
    int t;
    std::cin >> t;
    while (t--)
    {
        solve();
    }
}