#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
T sqr(const T &x) {
  return x * x;
}
template <typename T>
T my_abs(const T &x) {
  return x < 0 ? -x : x;
}
const int INF = (int)1e9;
const long long LINF = (long long)6e18;
const long long INF64 = LINF;
const long long INFLL = LINF;
const long double EPS = 1e-15;
const long double PI = 3.1415926535897932384626433832795;
const long double ME = 1e-5;
const long long MOD = (int)1e9 + 7;
const long long MOD2 = (int)1e9 + 21;
const int SQN = 320;
const int LOGN = 17;
const int dx[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dy[] = {1, 1, 0, -1, -1, -1, 0, 1};
const int N = (int)(1 << 7) + 3;
const int STC = 50000;
vector<int> rg[N];
int mh;
vector<int> lvl[10];
void gen_test() {
  for (int i = 0; i < int(10); ++i) {
    lvl[i].clear();
  }
  for (int i = 0; i < int(N); ++i) {
    rg[i].clear();
  }
  mh = rand() % 5 + 2;
  int v = 0;
  for (int i = int(mh) - 1; i >= 0; --i) {
    for (int j = 0; j < int(1 << i); ++j) {
      lvl[i].push_back(v++);
    }
  }
  for (int i = 0; i < int(mh - 1); ++i) {
    for (int i0 = 0; i0 < int(int(lvl[i].size())); ++i0) {
      int i1 = i0 * 2;
      int i2 = i0 * 2 + 1;
      int v = lvl[i][i0];
      int u1 = lvl[i + 1][i1];
      int u2 = lvl[i + 1][i2];
      rg[v].push_back(u1);
      rg[v].push_back(u2);
      rg[u1].push_back(v);
      rg[u2].push_back(v);
    }
  }
  for (int i = 0; i < int(v); ++i) {
    random_shuffle(rg[i].begin(), rg[i].end());
  }
}
vector<int> g[N];
set<int> cs[N];
int GCNT = 0;
void ans(int v) {
  printf("! %d\n", v + 1);
  fflush(stdout);
}
bool q(int v) {
  GCNT++;
  printf("? %d\n", v + 1);
  fflush(stdout);
  int cnt;
  scanf("%d", &cnt);
  for (int i = 0; i < int(cnt); ++i) {
    int cv;
    scanf("%d", &cv);
    cv--;
    g[v].push_back(cv);
  }
  if (int(g[v].size()) == 2) {
    ans(v);
    return true;
  }
  return false;
}
bool fp(int v, int p, vector<int> &path) {
  while (true) {
    if (q(v)) {
      return true;
    }
    if (int(g[v].size()) == 1) {
      path.push_back(v);
      break;
    }
    int idx = 0;
    if (g[v][idx] == p) {
      idx++;
    }
    path.push_back(v);
    p = v;
    v = g[v][idx];
  }
  return false;
}
void solve1() {
  cin >> mh;
  int v = 0;
  if (q(v)) {
    return;
  }
  vector<int> p1;
  if (int(g[v].size()) > 1) {
    if (fp(g[v][0], v, p1)) {
      return;
    }
    reverse(p1.begin(), p1.end());
    p1.push_back(v);
    vector<int> p2;
    if (fp(g[v][1], v, p2)) {
      return;
    }
    for (int i = 0; i < int(int(p2.size())); ++i) {
      p1.push_back(p2[i]);
    }
  } else {
    p1.push_back(v);
  }
  int h = int(p1.size()) / 2;
  v = p1[h];
  if (int(g[v].size()) > 1) {
    cs[v].insert(p1[h - 1]);
    cs[v].insert(p1[h + 1]);
  }
  vector<int> lpath;
  for (int i = 0; i < int(int(p1.size())); ++i) {
    if (p1[i] == v) {
      break;
    }
    lpath.push_back(p1[i]);
  }
  while (h < mh - 4) {
    int idx = 0;
    while (cs[v].count(g[v][idx])) {
      idx++;
    }
    vector<int> rpath;
    if (fp(g[v][idx], v, rpath)) {
      return;
    }
    lpath.push_back(v);
    for (int i = 0; i < int(int(rpath.size())); ++i) {
      lpath.push_back(rpath[i]);
    }
    h = int(lpath.size()) / 2;
    v = lpath[h];
    cs[v].insert(lpath[h - 1]);
    cs[v].insert(lpath[h + 1]);
    rpath.clear();
    for (int i = 0; i < int(int(lpath.size())); ++i) {
      if (lpath[i] == v) {
        break;
      }
      rpath.push_back(lpath[i]);
    }
    lpath = rpath;
  }
  if (h == mh - 4) {
    int idx = 0;
    while (cs[v].count(g[v][idx])) {
      idx++;
    }
    int u = g[v][idx];
    if (q(u)) {
      return;
    }
    for (int i = 0; i < int(int(g[u].size())); ++i) {
      int w = g[u][i];
      if (w != v) {
        if (q(w)) {
          return;
        }
        for (int j = 0; j < int(int(g[w].size())); ++j) {
          int ww = g[w][j];
          if (ww == u) {
            continue;
          }
          if (GCNT != 16) {
            if (q(ww)) {
              return;
            }
          } else {
            ans(ww);
            return;
          }
        }
      }
    }
    assert(4 > 0);
  }
  if (h == mh - 3) {
    int idx = 0;
    while (cs[v].count(g[v][idx])) {
      idx++;
    }
    int u = g[v][idx];
    if (q(u)) {
      return;
    }
    for (int i = 0; i < int(int(g[u].size())); ++i) {
      int w = g[u][i];
      if (w != v) {
        if (q(w)) {
          return;
        }
      }
    }
    assert(4 > 0);
  }
  if (h == mh - 2) {
    int idx = 0;
    while (cs[v].count(g[v][idx])) {
      idx++;
    }
    int u = g[v][idx];
    if (q(u)) {
      return;
    }
    assert(5 > 0);
  }
  if (h == mh - 1) {
    ans(v);
  }
  assert(0 > 0);
}
void solve() {
  int tc;
  cin >> tc;
  for (int i = 0; i < int(tc); ++i) {
    GCNT = 0;
    for (int i = 0; i < int(N); ++i) {
      g[i].clear();
      cs[i].clear();
    }
    solve1();
  }
}
int main() {
  ios_base::sync_with_stdio(false);
  srand((unsigned int)time(NULL));
  cout << setprecision(15) << fixed;
  solve();
  return 0;
}
