#include <bits/stdc++.h>

using LL = long long;

constexpr int inf = 1E9;

int ask(int a, int b)
{
    std::cout << "? " << a + 1 << ' ' << b + 1 << std::endl;
    int x;
    std::cin >> x;
    return x;    
}
void put(int x)
{
    std::cout << "! " << x + 1 << std::endl;
}

void solve()
{
    int n;
    std::cin >> n;

    std::vector<std::vector<int>> adj(n);
    for (int i = 0; i < n; i++)
    {
        int v1, v2;
        std::cin >> v1 >> v2;
        v1--, v2--;
        if (v1 >= 0)
        {
            adj[i].emplace_back(v1);
            adj[v1].emplace_back(i);
        }
        if (v2 >= 0)
        {
            adj[i].emplace_back(v2);
            adj[v2].emplace_back(i);
        }
    }

    std::vector<int> vis(n), size(n);
    int cent = -1, root = 0;
    int m = -1;

    auto dfs1 = [&](auto &&self, int x, int fx) -> int
    {
        size[x] = 1;
        for (auto y : adj[x])
        {
            if (vis[y] || y == fx)
            {
                continue;
            }
            size[x] += self(self, y, x);
        }
        return size[x];
    };
    auto dfs2 = [&](auto &&self, int x, int fx) -> void
    {
        int val = 0;
        for (auto y : adj[x])
        {
            if (vis[y] || y == fx)
            {
                continue;
            }
            self(self, y, x);
            val = std::max(val, size[y]);
        }
        val = std::max(val, m - size[x]);
        if (val <= m / 2)
        {
            cent = x;
        }
    };

    while (true)
    {
        m = dfs1(dfs1, root, -1);
        dfs2(dfs2, root, -1);

        std::vector<int> e;
        for (auto y : adj[cent])
        {
            if (vis[y])
            {
                continue;
            }
            e.emplace_back(y);
        }

        if (e.size() == 0)
        {
            put(root);
            return;
        }
        else if (e.size() == 1)
        {
            int q = ask(cent, e[0]);
            assert(q != 1);
            if (q == 0)
            {
                root = cent;
                vis[e[0]] = true;
            }
            else
            {
                root = e[0];
                vis[cent] = true;
            }
        }
        else
        {
            if (e.size() == 3)
            {
                std::array<int, 3> r = {0, 1, 2};
                std::array<int, 3> s = {size[e[0]], size[e[1]], size[e[2]]};
                int i = std::max_element(s.begin(), s.end()) - s.begin();
                s[i] = m - s[i] + 1;
                std::sort(r.begin(), r.end(), 
                    [&](int i, int j)
                    {
                        return s[i] > s[j];
                    });
                auto _e = e;
                _e[0] = e[r[0]];
                _e[1] = e[r[1]];
                e = _e;
            }
            int q = ask(e[0], e[1]);
            if (q == 0)
            {
                root = e[0];
                vis[cent] = true;
            }
            else if (q == 2)
            {
                root = e[1];
                vis[cent] = true;
            }
            else
            {
                root = cent;
                vis[e[0]] = true;
                vis[e[1]] = true;
            }
        }
    }
}

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

    int T;
    std::cin >> T;

    while (T--)
    {
        solve();
    }

    return 0;
}