#include <bits/stdc++.h>

// #include "../cpp-dump/cpp-dump.hpp"

template <class T>
using V = std::vector<T>;
template <class T>
void chkmin(T &x, const T &y) {
  if (x > y) x = y;
}
using ll = long long;

int n = 10, rx = 9, ry = 1, cnt;

int dis(int u, int v) { return std::min(std::abs(u - v), n - std::abs(u - v)); }
int query(int x, int y) {
  // return std::min({dis(x, y), std::min(dis(x, rx), dis(x, ry)) +
  //                                 std::min(dis(y, rx), dis(y, ry)) + 1});
  // std::cout << "? " << x + 1 << ' ' << y + 1 << std::endl;
  int r;
  std::cin >> r;
  return r;
}

void answer(int x, int y) {
  // assert(((x == rx && y == ry) || (x == ry && y == rx)) && cnt <= 40);
  // cnt = 0;
  // return;
  std::cout << "! " << x + 1 << ' ' << y + 1 << std::endl;
  int r;
  std::cin >> r;
  assert(r == 1);
}

std::mt19937 rnd(10);

int main() {
  std::cin.tie(0)->sync_with_stdio(0);
  int t;
  std::cin >> t;
  while (t--) {
    int n;
    // std::cin >> n;

    n = ::n;
    rx = rnd() % n;
    ry = rnd() % n;
    while (dis(rx, ry) <= 1) ry = rnd() % n;

    // cpp_dump(rx, ry);

    int m = n * 2;
    auto qo = [&](int u) {
      int r = 1e9, v = (u + m / 2) % m;
      chkmin(r, query(u / 2, v / 2));
      if (u & 1) chkmin(r, query(u / 2 + 1, v / 2));
      if (v & 1) chkmin(r, query(u / 2, v / 2 + 1));
      if ((u & 1) && (v & 1)) chkmin(r, query(u / 2 + 1, v / 2 + 1));
      return r * 2 + (u & 1) + (v & 1);
    };
    auto solve1 = [&](int u, int l) {
      int s = (n - l + 1) / 2;
      // for (int i = 0; i < n; i++)
      //   std::cerr << query(u, u + i) << " \n"[i == n - 1];
      if (query(u, (u + s) % n) == s && query(u, (u + s + 1) % n) != s + 1) {
        if (query((u + s + l / 2) % n, ((u + s + l / 2 - l) % n + n) % n) == 1)
          return answer((u + s + l / 2) % n, ((u + s + l / 2 - l) % n + n) % n);
        u = (u + s) % n;
      }
      int d = 0;
      for (int i = 30; i >= 0; i--)
        while (query(u, (u + d + (1 << i)) % n) == d + (1 << i)) d += (1 << i);
      answer((u + d + l / 2) % n, ((u + d + l / 2 - l) % n + n) % n);
    };
    auto solve2 = [&](int u) {
      int l = std::min(qo((u + m / 4) % m), qo((u + m / 4 + 1) % m));
      l = m / 2 - l + 2;
      if (query((u - l / 2 + m) % m / 2, (u + l / 2) % m / 2) != 1)
        u = (u + m / 2) % m;
      answer((u - l / 2 + m) % m / 2, (u + l / 2) % m / 2);
    };
    int d0 = qo(0), d1 = qo(1);
    if (d0 == d1) {
      if ((n & 1) && d0 == 3) {
        if (query(0, n / 2) == 1) {
          answer(0, n / 2);
          continue;
        }
        if (query(0, n / 2 + 1) == 1) {
          answer(0, n / 2 + 1);
          continue;
        }
      }
      if (d0 == m / 2) {
        int p = 0;
        if (qo((p + 1) % m) != m / 2) p = (p - 1 + m) % m;
        if (qo((p - 1 + m) % m) != m / 2) p = (p + 1) % m;
        solve2(p);
      } else
        solve1(0, (m / 2 - d0 + 2) / 2);
    } else {
      int c = (m / 2 - d0) / 2;
      int p = (d0 < d1 ? c : (-c + m) + m) % m;
      assert(qo(p) == m / 2);
      if (qo((p + 1) % m) != m / 2) p = (p - 1 + m) % m;
      if (qo((p - 1 + m) % m) != m / 2) p = (p + 1) % m;
      solve2(p);
    }
  }
}