Problem: This is an interactive problem.

You are the head coach of a chess club. The club has 2n players, each player has some strength which can be represented by a number, and all those numbers are distinct. The strengths of the players are not known to you.

You need to select n players who would represent your club in the upcoming championship. Naturally, you want to select n players with the highest strengths.

You can organize matches between the players to do that. In every match, you pick two players, they play some games, and you learn which one of the two has higher strength. You can wait for the outcome of a match before deciding who will participate in the next one.

However, you do not want to know exactly how those n players compare between themselves, as that would make the championship itself less intriguing. More formally, you must reach a state where there is exactly one way to choose n players with the highest strengths that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by strength that are consistent with the outcomes of the matches you organized.

Interaction

Your program has to process multiple test cases in one run. First, it should read the integer t (t ≥ 1) — the number of test cases. Then, it should process the test cases one by one.

In each test case, your program should start by reading the integer n (3 ≤ n ≤ 100) — the number of players to select out of 2n players. The sum of squares of the values of n over all test cases does not exceed 10 000.

Then your program can organize matches zero or more times. To organize a match, your program should print a match description formatted as ? i j — a question mark followed by two distinct numbers of players participating in the match. The players are numbered from 1 to 2n, inclusive. Remember to flush the output after printing the match description. Then your program should read the match outcome — it will be either the greater-than character (>), if the first player in the match description has higher strength, or the less-than character (<), if the second player in the match description has higher strength.

Your program can organize at most 4n^2 matches. After it is done organizing matches, it should print the exclamation mark (!) and continue to the next test case, or exit gracefully if this was the last test case. Remember to flush the output after printing the exclamation mark.

There must be exactly one way to choose n players with the highest strength that is consistent with the outcomes of the matches you organized, but there must be at least two possible orderings of those n players by their strength that are consistent with the outcomes of the matches you organized.

The judging program picks some distinct numbers as the strengths of all players before your program starts organizing matches and uses them to answer the requests.

Example

Input


2
3

&gt;

&lt;

&gt;

&lt;

&gt;

&gt;

3

&lt;

&lt;

&lt;

&gt;

&gt;


Output




? 1 3

? 4 2

? 4 5

? 6 5

? 3 4

? 5 6

!

? 3 4

? 4 2

? 5 3

? 6 4

? 3 1

!

Note

In the example, the players in the first test case are sorted by strength in decreasing order. From the matches in the example output, we can deduce that players 1, 2, and 3 have the highest strength, but we do not know how the player 1 compares to the player 2.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
inline __attribute__((always_inline)) void init_io() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  std::cout.tie(nullptr);
  std::fixed(std::cout).precision(20);
}
template <class... Args>
inline __attribute__((always_inline)) bool read(Args&... args) {
  return (bool)(std::cin >> ... >> args);
}
template <class... Args>
inline __attribute__((always_inline)) void write(Args&&... args) {
  (std::cout << ... << std::forward<Args>(args));
}
template <class... Args>
inline __attribute__((always_inline)) void writeln(Args&&... args) {
  (std::cout << ... << std::forward<Args>(args)) << '\n';
}
inline __attribute__((always_inline)) void flush() { std::flush(std::cout); }
template <class F, class S>
std::ostream& operator<<(std::ostream& os, const std::pair<F, S>& pr) {
  return os << "(" << pr.first << ", " << pr.second << ")";
}
template <class Key, class Val>
std::string map_to_string(const std::map<Key, Val>& mp) {
  std::stringstream ss;
  ss << "{";
  bool fst = true;
  for (const auto& it : mp) {
    ss << (fst ? "" : ", ") << it.first << ':' << it.second;
    fst = false;
  }
  ss << "}";
  return ss.str();
}
struct cmp_case_t {
  static bool get(int a, int b) {
    writeln("? ", a, ' ', b);
    flush();
    char res[3];
    read(res);
    return res[0] == '<';
  }
  mutable std::map<std::pair<int, int>, bool> mem;
  bool operator()(int a, int b) const {
    if (a > b) return !(*this)(b, a);
    auto key = std::make_pair(a, b);
    auto it = mem.find(key);
    if (it != mem.end()) return it->second;
    return mem[key] = get(a, b);
  }
};
struct cmp_t {
  const cmp_case_t* it;
  bool operator()(int a, int b) const { return (*it)(a, b); }
};
int main() {
  init_io();
  int t;
  read(t);
  while (t-- > 0) {
    int n;
    read(n);
    cmp_case_t qus;
    cmp_t cmp{&qus};
    std::vector<int> small = {1};
    std::set<int, cmp_t> big(cmp);
    for (int i = 2; i <= n; ++i) big.insert(i);
    for (int i = 1; i <= n; ++i) {
      int it = n + i;
      assert(small.size() + big.size() == n);
      if (small.size() == 1) {
        small.push_back(it);
        if (cmp(small[0], small[1])) std::swap(small[0], small[1]);
      } else {
        big.insert(it);
      }
      int sv = small.back();
      int bv = *big.begin();
      if (cmp(bv, sv)) {
        big.erase(big.begin());
      } else {
        small.pop_back();
      }
    }
    writeln("!");
    flush();
  }
  return 0;
}