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

using ll = long long;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rep2(i, l, r) for(ll i = l; i < r; i++)

using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;

/* ---- */
#define all(A) A.begin(), A.end()
#define elif else if
using pii = pair<ll, ll>;

bool chmin(auto &a, const auto &b) {return a > b ? a = b, 1 : 0;}
bool chmax(auto &a, const auto &b) {return a < b ? a = b, 1 : 0;}

struct IOSetup {
  IOSetup() {
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
} iosetup;

template<class T>
void print(vector<T> a) {
  for (auto x : a) cerr << x << ' ';
  cerr << endl;
}

void print(auto x) {
  cerr << x << endl;
}

template<class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
  cerr << head << ' ';
  print(forward<Tail>(tail)...);
}

mt19937_64 rng(2024); // [0, 2^64)
ll randint(ll l, ll r) { return l + rng() % (r - l + 1); }


int n;
vvi G;


int dbg=0;
int ans_s;

vvi dist;

int ask_cnt;
void INPUT(){
  ask_cnt=0;
  if(dbg){
    n=randint(5,100);
    ans_s=randint(0,n-1);
    G.assign(n,{});
    vi ord(n,0);
    dist.assign(n,vi(n,n));
    rep2(v,1,n){
      int p=randint(0,v-1);
      G[p].push_back(v);
      G[v].push_back(p);
      dist[v][p]=1;
      dist[p][v]=1;
    }
    rep(v,n)dist[v][v]=0;
    rep(k,n){
      rep(i,n){
        rep(j,n){
          dist[i][j]=min(dist[i][j],dist[i][k]+dist[k][j]);
        }
      }
    }

    bool flag=true;
    rep(i,n){
      if(G[i].size()>=4)flag=false;
    }
    if(!flag)return INPUT();
    
    rep(v,n){
      for(auto u:G[v]){
        if(v<u){
          print("edge :",v,u);
        }
      }
    }
    print("dist");
    for(auto x:dist)print(x);
    print("n, ans_s:",n,ans_s);
    return;
  }
  cin>>n;
  G.assign(n,{});
  rep(v,n){
    int l,r;
    cin>>l>>r;
    l--;r--;
    if(l!=-1){
      G[l].push_back(v);
      G[v].push_back(l);
    }
    if(r!=-1){
      G[r].push_back(v);
      G[v].push_back(r);
    }
  }
}

void answer(int v){
  cout<<"! "<<v+1<<endl;
  if(dbg){
    assert(v==ans_s);
  }
  assert((1<<ask_cnt)<=n);
}

int ask(int u,int v){
  ask_cnt++;
  cout<<"? "<<u+1<<" "<<v+1<<endl;
  if(dbg){
    int du=dist[u][ans_s];
    int dv=dist[v][ans_s];
    if(du<dv)return 0;
    if(du==dv)return 1;
    return 2;
  }
  int t;
  cin>>t;
  return t;
}



void solve(){
  INPUT();
  vector<int>ok(n,1);
  while(true){
    int r=-1;
    int sz=0;
    rep(v,n){
      if(ok[v]==1){
        sz++;
        r=v;
      }
    }
    if(sz==1){
      answer(r);
      return;
    }
    if(sz==2){
      vector<int>cand;
      rep(v,n){
        if(ok[v]==1)cand.push_back(v);
      }
      int v0=cand[0];
      int v1=cand[1];
      int t=ask(v0,v1);
      if(t==0)answer(v0);
      else answer(v1);
      return;
    }
    vi dp(n,0);
    int cent;
    auto dfs=[&](auto dfs,int v,int p)->void{
      if(ok[v]==0)return;
      dp[v]=1;
      for(auto u:G[v]){
        if(p!=u)dfs(dfs,u,v);
      }
      if(p!=-1)dp[p]+=dp[v];
      bool flg=true;
      for(auto u:G[v]){
        if(ok[u]==0||u==p)continue;
        if(dp[u]>sz/2)flg=false;
      }
      if(p!=-1&&sz-dp[v]>sz/2)flg=false;
      if(flg)cent=v;
    };
    dfs(dfs,r,-1);

    auto dfs_naive=[&](int v,int ng1,int ng2)->vi{
      vi seen(n,0);
      vi todo={v};
      seen[v]=1;
      if(ng1!=-1)seen[ng1]=1;
      if(ng2!=-1)seen[ng2]=1;
      vi grp;
      while(!todo.empty()){
        auto u=todo.back();
        grp.push_back(u);
        todo.pop_back();
        for(auto w:G[u]){
          if(seen[w]==0&&ok[w]==1){
            seen[u]=1;
            todo.push_back(w);
          }
        }
      }
      return grp;
    };

    vector<pair<int,int>>res;
    for(auto u:G[cent]){
      if(ok[u]==1){
        vi s=dfs_naive(u,cent,-1);
        res.push_back({s.size(),u});
      }
    }
    sort(res.rbegin(),res.rend());
    int v0,v1;
    v0=res[0].second;
    v1=res[1].second;
    if(dbg){
      print("cent, v0, v1 :",cent,v0,v1);
    }

    vi grp0=dfs_naive(v0,cent,-1);
    vi grp1=dfs_naive(v1,cent,-1);
    vi grp2=dfs_naive(cent,v0,v1);
    int t=ask(v0,v1);
    vi nok(n,0);
    if(t==0){
      for(auto v:grp0)nok[v]=1;
    }
    else if(t==2){
      for(auto v:grp1)nok[v]=1;
    }
    else{
      for(auto v:grp2)nok[v]=1;
    }
    ok=nok;
  }
}

int main(){
  int T;
  if(dbg)T=10000;
  else cin>>T;
  while(T--)solve();
}