#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int N;
int mod(int u) {
  return (u % N + N) % N;
}

#ifdef LOCAL
vector<vector<int>> D;
void build(int a, int b) {
  D.assign(N, vector<int>(N, N));
  for (int u = 0; u < N; ++u) D[u][u] = 0;
  for (int u = 0; u < N; ++u) {
    const int v = (u + 1) % N;
    chmin(D[u][v], 1);
    chmin(D[v][u], 1);
  }
  chmin(D[a][b], 1);
  chmin(D[b][a], 1);
  for (int w = 0; w < N; ++w) for (int u = 0; u < N; ++u) for (int v = 0; v < N; ++v) {
    chmin(D[u][v], D[u][w] + D[w][v]);
  }
}
int dist(int u, int v) {
  return D[mod(u)][mod(v)];
}

void exper() {
  for (N = 8; N <= 20; ++N) {
    map<pair<int, vector<int>>, vector<pair<int, int>>> f;
    for (int a = 0; a < N; ++a) for (int b = a + 1; b < N; ++b) {
      if ((a + 1) % N == b) continue;
      if ((b + 1) % N == a) continue;
      build(a, b);
      vector<int> us{0, N/4, 1 + N/2, 1 - N/2};
      vector<int> ds;
      for (const int u : us) ds.push_back(dist(u, u + N/2));
// cerr<<N<<" "<<a<<" "<<b<<": "<<us<<" "<<ds<<endl;
      assert(*min_element(ds.begin(), ds.end()) < N/2);
      const int d0 = ds[0];
      if (d0 < N/2) {
        vector<int> es;
        es.push_back((dist(1, N/2) < d0) ? +1 : (dist(-1, N/2) < d0) ? -1 : 0);
        es.push_back((dist(0, N/2 + 1) < d0) ? +1 : (dist(0, N/2 - 1) < d0) ? -1 : 0);
        f[make_pair(d0, es)].emplace_back(a, b);
      }
    }
    cerr << "N = " << N << endl;
    for (const auto &kv : f) {
      set<int> ds;
      for (const auto &p : kv.second) {
        const int a = p.first;
        const int b = p.second;
        const int d = min((b - a + N) % N, (a - b + N) % N);
        ds.insert(d);
      }
      cerr << kv << " "; pv(ds.begin(), ds.end());
    }
    cerr << endl;
  }
}
#endif

int ask(int u, int v) {
  assert(0 <= u); assert(u < N);
  assert(0 <= v); assert(v < N);
#ifdef LOCAL
  return D[u][v];
#else
  printf("? %d %d\n", u + 1, v + 1);
  fflush(stdout);
  int ret;
  scanf("%d", &ret);
  return ret;
#endif
}

int sgn(int x) {
  return (x < 0) ? -1 : (x > 0) ? +1 : 0;
}
pair<int, int> solve() {
  if (N < 8) {
    for (int a = 0; a < N; ++a) for (int b = a + 1; b < N; ++b) {
      if ((a + 1) % N == b) continue;
      if ((b + 1) % N == a) continue;
      if (ask(a, b) == 1) return make_pair(a, b);
    }
  }
  int S = 0, T = 0;
  auto d = [&](int u, int v) -> int {
    return ask(mod(S + u), mod(S + v));
  };
  int D0 = N/2;
  for (const int s : {0, N/4, 1 + N/2, 1 - N/2}) {
    S = s;
    D0 = d(0, N/2);
    if (D0 < N/2) {
      break;
    }
  }
  assert(D0 < N/2);
  if (D0 == 1) {
    return make_pair(mod(S), mod(S + N/2));
  }
  int e0 = sgn(D0 - d(1, N/2));
  int e1 = sgn(D0 - d(0, N/2 + 1));
  // if (!e0) e0 = -e1;
  // if (!e1) e1 = -e0;
  // if (!e0 && !e1) { e0 = +1; e1 = -1; }
  if (!e0) e0 = -1;
  if (!e1) e1 = -1;
// cerr<<"S = "<<S<<", D0 = "<<D0<<", e0 = "<<e0<<", e1 = "<<e1<<endl;
  bool ok = false;
  if (e0 > 0) {
    if (e1 > 0) {
      const int sum = D0 - 1 + N/2;
      S = mod(S + (sum - N/2) / 2);
    } else {
      ok = true;
      T = mod(S + N/2);
    }
  } else {
    if (e1 > 0) {
      ok = true;
      T = mod(S + N/2);
      swap(S, T);
    } else {
      const int sum = N/2 + N + 1 - D0;
      S = mod(S + (sum - N/2) / 2);
// cerr<<"sum = "<<sum<<", S = "<<S<<endl;
    }
  }
  if (!ok) {
    D0 = d(0, N/2);
    if (D0 == 1) {
      return make_pair(mod(S), mod(S + N/2));
    }
    e0 = sgn(D0 - d(1, N/2));
    e1 = sgn(D0 - d(0, N/2 + 1));
// cerr<<"S = "<<S<<", D0 = "<<D0<<", e0 = "<<e0<<", e1 = "<<e1<<endl;
    // if (!e0) e0 = -e1;
    // if (!e1) e1 = -e0;
    // if (!e0 && !e1) { e0 = +1; e1 = -1; }
    if (!e0) e0 = -1;
    if (!e1) e1 = -1;
    // assert(e0 != e1);
    T = mod(S + N/2);
    if (e0 < 0 || e1 > 0) swap(S, T);
  }
  
  const int sz = mod(T - S);
  const int len = sz - D0 + 1;
cerr<<COLOR("93")<<"S = "<<S<<", T = "<<T<<", D0 = "<<D0<<", sz = "<<sz<<", len = "<<len<<COLOR()<<endl;
  int lo = 0, hi = sz - len + 1;
  for (; lo + 1 < hi; ) {
    const int mid = (lo + hi) / 2;
    ((d(mid, sz) == D0 - mid) ? lo : hi) = mid;
  }
  return make_pair(mod(S + lo), mod(S + lo + len));
}

#ifdef LOCAL
void stress() {
  for (N = 4; N <= 40; ++N) {
    for (int a = 0; a < N; ++a) for (int b = a + 1; b < N; ++b) {
      if ((a + 1) % N == b) continue;
      if ((b + 1) % N == a) continue;
      build(a, b);
      cerr << N << " " << a << " " << b << endl;
      const auto res = solve();
      cerr << "  res = " << res << endl;
      assert(res == make_pair(a, b) || res == make_pair(b, a));
    }
  }
}
#endif

int main() {
  // exper();
  // stress();
  
  int T;
  scanf("%d", &T);
  for (int t = 0; t < T; ++t) {
    scanf("%d", &N);
    const auto res = solve();
    printf("! %d %d\n", res.first + 1, res.second + 1);
    fflush(stdout);
    int ret;
    scanf("%d", &ret);
    if (ret == -1) exit(0);
  }
  return 0;
}