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>
#pragma GCC optimize("O3")
using namespace std;
const int N = 2100031;
void stop_here() {
  cout << "!" << endl;
  return;
}
int tests, n;
int C;
int used[N];
int left_son[N], right_son[N];
int winner[N];
int where[N], par[N];
vector<pair<int, int> > edges;
int stress = 0;
string make_query(int a, int b) {
  if (stress == 0) cout << "? " << a << " " << b << endl;
  edges.push_back(make_pair(a, b));
  string ret;
  if (stress == 0) {
    cin >> ret;
    return ret;
  } else {
    if (a < b) return "<";
    return ">";
  }
}
int who_is_worse(int a, int b) {
  if (a == 0) return b;
  if (b == 0) return a;
  string compare_result = make_query(a, b);
  if (compare_result == "<") return a;
  return b;
}
void build_tree(int v, vector<int> candidates) {
  if (candidates.size() == 1) {
    winner[v] = candidates[0];
    where[candidates[0]] = v;
    return;
  }
  vector<int> left_candidates;
  vector<int> right_candidates;
  for (int i = 0; i < candidates.size(); i++) {
    if (i % 2)
      left_candidates.push_back(candidates[i]);
    else
      right_candidates.push_back(candidates[i]);
  }
  ++C;
  left_son[v] = C;
  par[C] = v;
  build_tree(C, left_candidates);
  ++C;
  par[C] = v;
  right_son[v] = C;
  build_tree(C, right_candidates);
  int here = who_is_worse(winner[left_son[v]], winner[right_son[v]]);
  winner[v] = here;
}
void rebuild(int v) {
  int here = who_is_worse(winner[left_son[v]], winner[right_son[v]]);
  winner[v] = here;
}
int get_minimum(int iter) {
  int res = winner[1];
  return res;
}
void run_update(int v) {
  if (v == 1) return;
  rebuild(par[v]);
  run_update(par[v]);
}
int good, bad;
bool have_edge(int a, int b) {
  for (int i = 0; i < edges.size(); i++) {
    if (edges[i].first == a && edges[i].second == b) return true;
    if (edges[i].first == b && edges[i].second == a) return true;
  }
  return false;
}
int main() {
  srand(13);
  if (stress == 0)
    cin >> tests;
  else
    tests = 10000;
  for (; tests; --tests) {
    if (stress == 0) cin >> n;
    edges.clear();
    for (int i = 0; i <= 5000; i++) {
      left_son[i] = right_son[i] = winner[i] = 0;
    }
    vector<int> v;
    C = 1;
    for (int i = 1; i <= n + 1; i++) {
      v.push_back(i);
    }
    build_tree(1, v);
    for (int i = n + 2; i <= n * 2; i++) {
      int Q = get_minimum(i);
      int v_id = where[Q];
      where[i] = v_id;
      winner[v_id] = i;
      run_update(v_id);
    }
    int ok = 0;
    for (int i = n + 1; i < n * 2; i++)
      if (have_edge(i, i + 1) == 0) ok = 1;
    if (ok == 0) {
      bad++;
    } else {
      good++;
    }
    stop_here();
  }
  return 0;
}