Problem: This is an interactive problem. Don't forget to flush output after printing queries using cout.flush() or fflush(stdout) in C++ or similar functions in other programming languages.

There are n gift boxes in a row, numbered from 1 to n from left to right. It's known that exactly k of them contain valuable gifts — other boxes contain just lucky stones. All boxes look the same and differ only in weight. All boxes with stones have the same weight and are strictly heavier than boxes with valuable items. But valuable gifts may be different, so the boxes with valuable items may have different weights.

You can ask no more than 50 queries (printing an answer doesn't count). By each query you can compare total weights of two non-intersecting subsets of boxes a_1, a_2, ..., a_{k_a} and b_1, b_2, ..., b_{k_b}. In return you'll get one of four results:

  * FIRST, if subset a_1, a_2, ..., a_{k_a} is strictly heavier; 
  * SECOND, if subset b_1, b_2, ..., b_{k_b} is strictly heavier; 
  * EQUAL, if subsets have equal total weights; 
  * WASTED, if the query is incorrect or the limit of queries is exceeded. 



Using such queries (or, maybe, intuition) find the box with a valuable gift with the minimum index.

Input

The input consists of several cases. In the beginning, you receive the integer T (1 ≤ T ≤ 500) — the number of test cases.

At the beginning of each test case, you receive two integers n and k (2 ≤ n ≤ 1000, 1 ≤ k ≤ n/2) — the number of boxes in a row and the number of boxes with valuable gifts.

It's guaranteed that the order of boxes is fixed beforehand and that the sum of n in one test doesn't exceed 1000.

Output

For each test case print the minimum index among all boxes with a valuable gift in the following format: "! x" where x (1 ≤ x ≤ n) — the index of the box.

Interaction

Print each query in three lines. In the first line print the sizes of subset in the following format: "? k_a k_b" where k_a and k_b (1 ≤ k_a, k_b ≤ n; k_a + k_b ≤ n) — the corresponding sizes.

In the second line print k_a integers a_1, a_2, ..., a_{k_a} (1 ≤ a_i ≤ n; a_i ≠ a_j if i ≠ j) — indexes of boxes in the first subset.

In the third line print k_b integers b_1, b_2, ..., b_{k_b} (1 ≤ b_i ≤ n; b_i ≠ b_j if i ≠ j) — indexes of boxes in the second subset.

The subsets shouldn't intersect, i. e. a_i ≠ b_j for all i and j.

You'll receive one of four responses described above. In the case of WASTED stop your program to avoid getting random verdict instead of Wrong Answer.

Example

Input


2
2 1
-
-
-
FIRST
-
5 2
-
-
-
FIRST
-
-
-
SECOND
-
-
-
EQUAL
-

Output


-
-
? 1 1
1
2
-
! 2
-
? 1 1
1
2
-
? 2 3
4 2
1 3 5
-
? 1 1
4
5
-
! 1

Note

Additional separators "–" in the sample are used only to increase the readability of the sample. Don't print any unnecessary symbols or line breaks in your solution when you send it to the system.

Hacks are forbidden in this task.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.util.Random;
import java.io.IOException;
import java.util.function.Function;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author out_of_the_box
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        GFindAGift solver = new GFindAGift();
        solver.solve(1, in, out);
        out.close();
    }

    static class GFindAGift {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int t = in.nextInt();
            for (int i = 0; i < t; i++) {
                int n = in.nextInt();
                int k = in.nextInt();

                boolean done = false;
                for (int j = 0; j < 30; j++) {
                    int rand = getRandomIndex(n);
                    GFindAGift.Response res = query(1, rand, out, in);
                    if (res == GFindAGift.Response.SECOND) {
                        out.println("! 1");
                        out.flush();
                        done = true;
                        break;
                    }
                }
                if (done) {
                    continue;
                }

                int r = 1;
                int st = n - k;
                while (r < st) {
                    int dr = r << 1;
                    if (dr >= n) {
                        break;
                    }
                    GFindAGift.Response res = query(1, r, r + 1, dr, out, in);
                    if (res != GFindAGift.Response.EQUAL) {
                        break;
                    }
                    r = dr;
                }

                int finalR = r;
                Function<Integer, Boolean> func = ind -> !(query(finalR + 1, ind, 1, ind - finalR, out, in) == GFindAGift.Response.EQUAL);
                int end = Math.min(2 * r + 1, n + 1);
                int ans = BinarySearch.searchFirstOne(r + 1, end, func);
                MiscUtility.assertion(ans != end);
                out.println("! " + ans);
                out.flush();
            }
        }

        private GFindAGift.Response query(int fi, int fj, int si, int sj, OutputWriter out, InputReader in) {
            int sf = fj - fi + 1;
            int ss = sj - si + 1;
            out.println(String.format("? %d %d", sf, ss));
            out.flush();
            for (int i = fi; i <= fj; i++) {
                out.print(i + " ");
            }
            out.println();
            out.flush();
            for (int i = si; i <= sj; i++) {
                out.print(i + " ");
            }
            out.println();
            out.flush();

            String res = in.nextString();
            return GFindAGift.Response.valueOf(res);
        }

        private GFindAGift.Response query(int i, int j, OutputWriter out, InputReader in) {
            out.println("? 1 1");
            out.flush();
            out.println(i);
            out.flush();
            out.println(j);
            out.flush();

            String res = in.nextString();
            return GFindAGift.Response.valueOf(res);
        }

        private int getRandomIndex(int n) {
            if (n == 2) return 2;
            return new Random().nextInt(n - 2) + 2;
        }

        private enum Response {
            FIRST,
            SECOND,
            EQUAL,
            WASTED,
            ;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println() {
            writer.println();
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

        public void flush() {
            writer.flush();
        }

        public void println(int i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String nextString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                if (Character.isValidCodePoint(c)) {
                    res.appendCodePoint(c);
                }
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class BinarySearch {
        public static int searchFirstOne(int start, int end, Function<Integer, Boolean> valueFunc) {
            int low = start;
            int high = end - 1;
            while (low < high) {
                int mid = low + (high - low) / 2;
                if (valueFunc.apply(mid)) {
                    high = mid;
                } else {
                    low = mid + 1;
                }
            }

            if (valueFunc.apply(low)) {
                return low;
            } else {
                return end;
            }
        }

    }

    static class MiscUtility {
        public static void assertion(boolean condition) {
            if (!condition) {
                throw new RuntimeException("Assertion failed");
            }
        }

    }
}