#include <bits/stdc++.h>
using namespace std;
int H;
bool is_queried[128];
int asked;
int height[128];
int P[128];
vector<int> neighbors[128];
;
bool query(int node) {
  if (is_queried[node]) return false;
  if (asked >= 16) throw "BAD";
  is_queried[node] = true;
  asked++;
  cout << "? " << node << endl << flush;
  int K;
  cin >> K;
  neighbors[node].resize(K);
  if (!K) exit(0);
  for (int x = 0; x < (K); ++x) cin >> neighbors[node][x];
  return true;
}
void answer(int node) { cout << "! " << node << endl << flush; }
void clear() {
  asked = 0;
  for (int i = 0; i < (128); ++i) neighbors[i].clear();
  memset(height, -1, sizeof(height));
  memset(is_queried, 0, sizeof(is_queried));
  memset(P, 0, sizeof(P));
}
int get_distance_to_leaf(int node, int from, int max_depth) {
  query(node);
  if (neighbors[node].size() == 2) return H;
  if (neighbors[node].size() == 1) return 0;
  if (max_depth == 1) return 10000;
  for (const int& j : neighbors[node]) {
    if (j == from) continue;
    return 1 + get_distance_to_leaf(j, node, max_depth - 1);
  }
  throw "BAD";
  ;
}
void do_final_bfs(int src) {
  for (int i = (1); i <= ((1 << H) - 1); ++i) {
    if (is_queried[i] && (neighbors[i].size() == 2 || height[i] == 1))
      return void(answer(i));
  }
  queue<int> Q;
  Q.push(src);
  while (!Q.empty()) {
    int node = Q.front();
    Q.pop();
    if (asked == 16 && !is_queried[node]) {
      return void(answer(node));
    }
    query(node);
    if (neighbors[node].size() == 2 || height[node] == 1)
      return void(answer(node));
    for (const int& j : neighbors[node]) {
      Q.push(j);
    }
  }
}
void solve() {
  int node = 1;
  query(node);
  if (neighbors[node].size() == 2)
    return void(answer(node));
  else if (neighbors[node].size() == 1) {
    height[node] = H;
    P[node] = neighbors[node][0];
    height[P[node]] = H - 1;
  } else {
    int d1 = get_distance_to_leaf(neighbors[node][0], node, 5);
    int d2 = get_distance_to_leaf(neighbors[node][1], node, 5);
    ;
    height[node] = H - min(d1, d2) - 1;
    if (d1 == d2) {
      P[node] = neighbors[node][2];
    } else if (d1 > d2) {
      P[node] = neighbors[node][0];
    } else {
      P[node] = neighbors[node][1];
    }
    height[P[node]] = height[node] - 1;
  }
  int last = node;
  while (true) {
    ;
    ;
    last = node;
    node = P[node];
    query(node);
    if (neighbors[node].size() == 2 || height[node] == 1)
      return void(answer(node));
    ;
    if (height[node] <= 3) {
      return void(do_final_bfs(node));
    }
    int x = -1;
    for (const auto& j : neighbors[node]) {
      if (!is_queried[j]) x = j;
    };
    ;
    int d = get_distance_to_leaf(x, node, H - height[node]);
    if (d < 10000) {
      ;
      if (d == H) return void(answer(x));
      x = (neighbors[node][0] + neighbors[node][1] + neighbors[node][2]) - x -
          last;
    }
    height[x] = height[node] - 1;
    P[node] = x;
    if (height[x] == 1 || neighbors[x].size() == 2) return void(answer(x));
  }
}
void do_test_case() {
  cin >> H;
  if (!H) exit(0);
  clear();
  solve();
}
int main() {
  int TEST;
  scanf("%d", &TEST);
  for (int test = 0; test < (TEST); ++test) {
    do_test_case();
  }
}
