Problem: This is an interactive problem. You have to use flush operation right after printing each line. For example, in C++ you should use function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().

In this problem, you need to find maximal and minimal elements of an array. What could be simpler?

You can imagine that the jury has an array, and initially you know the only number n — array's length.

Array's elements are numbered from 1 to n. You are allowed to compare two elements of the array by using their indices i and j. There are three possible responses to this query: '<' (if ai is less than aj), '=' (if ai is equal to aj) and finally '>' (if ai is greater than aj).

It's known that it's always possible to find both maximal and minimal elements of the array by using no more than <image> comparisons, where ⌈ x⌉ is the result of rounding x up.

Write the program that will find positions of the minimum and the maximum in the jury's array of length n, by using no more than f(n) comparisons.

Interaction

Each test for this problem will contain one or more arrays. You have to find positions of minimal and maximal elements for each of these arrays. The first line of the input contains integer T (1 ≤ T ≤ 1000) — number of arrays in the test.

Thus, at the beginning, you program should read number T, and then it should solve the problem for T jury's arrays one by one.

Then input for each array goes. Firstly, your program has to read the number n (1 ≤ n ≤ 50) — the length of the array. It will be provided in the next line of the input.

Further, your program can perform comparisons or report that the answer is found.

  * To perform a comparison, you have to output string of the following pattern «? i j» (i and j must be integer numbers from 1 to n) — the indices of the elements to compare in the current query. 
  * To report the indices of minimal and maximal elements of the hidden array, your program have to output a line in the form «! i j» (i and j must be integer numbers from 1 to n), where i is an index of the minimal element of array, and j is an index of the maximal element of the array. If there are several possible answers to the problem, you can output any of them. 



There are several possible responses for a comparison:

  * '<' — if ai is less than aj, 
  * '=' — if ai is equal to aj, 
  * '>' — if ai is greater than aj. 



For an array of length n your program can make at most <image> comparisons. Note that the operation of reporting an answer («! i j» ) is not included into the value of f(n).

After the answer is reported, your program has to solve the problem for the next array or it should terminate if all T arrays are processed.

Example

Input

2
2
 
&gt;
 
3
 
=
 
=
 

Output

 
 
? 1 2
 
! 2 1
 
? 3 1
 
? 2 1
 
! 2 3

Solution (in JAVA):

Solution:
/**
 * @author derrick20
 */
import java.io.*;
import java.util.*;

public class MinAndMax {
    public static void main(String[] args) throws Exception {
        sc = new FastScanner();
        out = new PrintWriter(System.out);

        int T = sc.nextInt();
        while (T-->0) {
            int N = sc.nextInt();

            if (N == 1) {
                System.out.println("! 1 1");
            }
            else {
                var left = new ArrayList<Integer>();
                var right = new ArrayList<Integer>();

                for (int i = 1, j = N; i < j; i++, j--) {
                    boolean less = isLess(i, j);
                    if (less) {
                        left.add(i);
                        right.add(j);
                    }
                    else {
                        // if equal or greater, swap them!
                        left.add(j);
                        right.add(i);
                    }
                }

                // remember the middle elemnet!
                if (N % 2 == 1) {
                    boolean less = isLess((N + 1) / 2, left.get(0));
                    // decide either to swap it out, or throw it out
                    if (less) {
                        left.set(0, (N + 1) / 2);
                    }

                    boolean less2 = isLess((N + 1) / 2, right.get(0));
                    // decide either to swap it out, or throw it out
                    if (!less2) {
                        right.set(0, (N + 1) / 2);
                    }
                    // else, it's discarded
                }

                int min = solveGroup(left, false);
                int max = solveGroup(right, true);
                System.out.println("! " + min + " " + max);
            }
        }
        out.close();
    }

    static FastScanner sc;
    static PrintWriter out;

    static boolean isLess(int i, int j) {
        System.out.println("? " + i + " " + j);
        char type = sc.next().charAt(0);
        return type == '<';
    }

    static int solveGroup(ArrayList<Integer> group, boolean maximizing) {
        while (group.size() > 1) {
//            System.out.println(group);
            var group2 = new ArrayList<Integer>();
            for (int a = 0, b = group.size() - 1; a < b; a++, b--) {
                int i = group.get(a);
                int j = group.get(b);
                boolean less = isLess(i, j);
                // if less and not maximizing, use it
                // if not less and maximizing, use it
                if (less  ^ maximizing) {
                    group2.add(i);
                }
                else {
                    // if less and maximizing, use the other
                    // if not less and not maximizing, use the other
                    // if equal or greater, swap them!
                    group2.add(j);
                }
            }
            if (group.size() % 2 == 1) {
                boolean less = isLess(group.get(group.size() / 2), group2.get(0));
                // decide either to swap it out, or throw it out
                // if less and not maximizing, insert it
                // if not less and maximizing, insert itAR
                if (less ^ maximizing) {
                    group2.set(0, group.get(group.size() / 2));
                }
                // else, it's discarded
            }
            group = group2;
        }
        return group.get(0);
    }

    static class FastScanner {
        private int BS = 1<<16;
        private char NC = (char)0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;

        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }

        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            }
            catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }

        private char getChar(){
            while(bId==size) {
                try {
                    size = in.read(buf);
                }catch(Exception e) {
                    return NC;
                }
                if(size==-1)return NC;
                bId=0;
            }
            return (char)buf[bId++];
        }

        public int nextInt() {
            return (int)nextLong();
        }

        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }

        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }

        public long nextLong() {
            cnt=1;
            boolean neg = false;
            if(c==NC)c=getChar();
            for(;(c<'0' || c>'9'); c = getChar()) {
                if(c=='-')neg=true;
            }
            long res = 0;
            for(; c>='0' && c <='9'; c=getChar()) {
                res = (res<<3)+(res<<1)+c-'0';
                cnt*=10;
            }
            return neg?-res:res;
        }

        public double nextDouble() {
            double cur = nextLong();
            return c!='.' ? cur:cur+nextLong()/cnt;
        }

        public String next() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c>32) {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while(c<=32)c=getChar();
            while(c!='\n') {
                res.append(c);
                c=getChar();
            }
            return res.toString();
        }

        public boolean hasNext() {
            if(c>32)return true;
            while(true) {
                c=getChar();
                if(c==NC)return false;
                else if(c>32)return true;
            }
        }
    }
}