Problem: There is a weighted tree with n nodes and n-1 edges. The nodes are conveniently labeled from 1 to n. The weights are positive integers at most 100. Define the distance between two nodes to be the sum of edges on the unique path between the nodes. You would like to find the diameter of the tree. Diameter is the maximum distance between a pair of nodes.

Unfortunately, the tree isn't given to you, but you can ask some questions about it. In one question, you can specify two nonempty disjoint sets of nodes p and q, and the judge will return the maximum distance between a node in p and a node in q. In the words, maximum distance between x and y, where x ∈ p and y ∈ q. After asking not more than 9 questions, you must report the maximum distance between any pair of nodes.

Interaction

Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1 000). Description of the test cases follows.

The first line of each test case contains an integer n (2 ≤ n ≤ 100) — the number of nodes in the tree.

To ask a question, print "k_1\ k_2\ a_1\ a_2\ …\ a_{k_1}\ b_1\ b_2\ …\ b_{k_2}" (k_1, k_2 ≥ 1 and k_1+k_2 ≤ n). These two sets must be nonempty and disjoint. The judge will respond with a single integer max_{p,q} dist(a_p, b_q). If you ever get a result of -1 (because you printed an invalid query), exit immediately to avoid getting other verdicts.

After printing a query do not forget to output end of line and flush the output. Otherwise, you will get Idleness limit exceeded. To do this, use:

  * fflush(stdout) or cout.flush() in C++;
  * System.out.flush() in Java;
  * flush(output) in Pascal;
  * stdout.flush() in Python;
  * see documentation for other languages.



When you are ready to answer, print "-1\ d", where d is the maximum shortest distance over all pairs of nodes.

You can only ask at most 9 questions per test case.

Hack Format

To hack, use the following format. Note that you can only hack with one test case.

The first line should contain a single integer t (t=1).

The second line should contain a single integer n (2 ≤ n ≤ 100).

Each of the next n-1 lines should contain three integers a_i, b_i, c_i (1≤ a_i, b_i≤ n, 1 ≤ c_i ≤ 100). This denotes an undirected edge between nodes a_i and b_i with weight c_i. These edges must form a tree.

Example

Input


2
5
9
6
10
9
10
2
99


Output


1 4 1 2 3 4 5
1 4 2 3 4 5 1
1 4 3 4 5 1 2
1 4 4 5 1 2 3
1 4 5 1 2 3 4
-1 10
1 1 1 2
-1 99

Note

In the first example, the first tree looks as follows: <image>

In the first question, we have p = {1}, and q = {2, 3, 4, 5}. The maximum distance between a node in p and a node in q is 9 (the distance between nodes 1 and 5).

The second tree is a tree with two nodes with an edge with weight 99 between them.

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Random;
import java.util.TreeSet;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
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);
        CTreeDiameter solver = new CTreeDiameter();
        solver.solve(1, in, out);
        out.close();
    }

    static class CTreeDiameter {
        public static void shuffle(int[] arr, Random rnd) {
            int n = arr.length;
            for (int i = 0; i < n; ++i) {
                int tmp = arr[i];
                int randomPos = i + rnd.nextInt(n - i);
                arr[i] = arr[randomPos];
                arr[randomPos] = tmp;
            }
        }

        ArrayList<Pair<TreeSet<Integer>, TreeSet<Integer>>> generate(int n, Random random) {
            while (true) {
                ArrayList<IntIntPair> old = new ArrayList<>();
                for (int i = 0; i < n; i++) {
                    for (int j = i + 1; j < n; j++) {
                        old.add(new IntIntPair(i, j));
                    }
                }
                int[] perm = new int[old.size()];
                for (int i = 0; i < perm.length; i++) {
                    perm[i] = i;
                }
                shuffle(perm, random);
                ArrayList<IntIntPair> al = new ArrayList<>();
                for (int idx : perm) al.add(old.get(idx));
                ArrayList<Pair<TreeSet<Integer>, TreeSet<Integer>>> res =
                        new ArrayList<>();
                while (!al.isEmpty()) {
                    TreeSet<Integer> left = new TreeSet<>();
                    TreeSet<Integer> right = new TreeSet<>();
                    ArrayList<IntIntPair> nal = new ArrayList<>();
                    for (IntIntPair iip : al) {
                        if ((left.contains(iip.first) && right.contains(iip.second)) ||
                                (left.contains(iip.second) && right.contains(iip.first))) {
                            // we are ok here
                        } else if ((left.contains(iip.first) && left.contains(iip.second)) ||
                                (right.contains(iip.first) && right.contains(iip.second))) {
                            // we can't do this one in this set
                            nal.add(iip);
                        } else if (left.contains(iip.first)) {
                            right.add(iip.second);
                        } else if (left.contains(iip.second)) {
                            right.add(iip.first);
                        } else if (right.contains(iip.first)) {
                            left.add(iip.second);
                        } else if (right.contains(iip.second)) {
                            left.add(iip.first);
                        } else {
                            left.add(iip.first);
                            right.add(iip.second);
                        }
                    }
                    for (int val : left) {
                        if (right.contains(val)) throw new RuntimeException();
                    }
                    for (int val : right) {
                        if (left.contains(val)) throw new RuntimeException();
                    }
                    res.add(Pair.makePair(left, right));
                    al = nal;
                }
                if (res.size() <= 9) return res;
            }
        }

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            Random random = new Random(12345);
            ArrayList<Pair<TreeSet<Integer>, TreeSet<Integer>>>[] mem =
                    new ArrayList[101];
            for (int i = 0; i < mem.length; i++) {
                mem[i] = new ArrayList<>();
            }
            for (int n = 2; n < mem.length; n++) {
                mem[n] = generate(n, random);
            }
            int tests = in.readInt();
            for (int test = 0; test < tests; test++) {
                int n = in.readInt();
                ArrayList<Pair<TreeSet<Integer>, TreeSet<Integer>>> answer = mem[n];
                int res = 0;
                for (Pair<TreeSet<Integer>, TreeSet<Integer>> pair : answer) {
                    TreeSet<Integer> a = pair.first;
                    TreeSet<Integer> b = pair.second;
                    out.print(a.size() + " " + b.size() + " ");
                    for (int val : a) out.print((val + 1) + " ");
                    for (int val : b) out.print((val + 1) + " ");
                    out.printLine();
                    out.flush();
                    res = Math.max(res, in.readInt());
                }
                out.printLine(-1, res);
                out.flush();
            }
        }
    }
    static class IntIntPair implements Comparable<IntIntPair> {
        public final int first;
        public final int second;

        public IntIntPair(int first, int second) {
            this.first = first;
            this.second = second;
        }

        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            IntIntPair pair = (IntIntPair) o;
            return first == pair.first && second == pair.second;
        }

        public int hashCode() {
            int result = first;
            result = 31 * result + second;
            return result;
        }

        public String toString() {
            return "(" + first + "," + second + ")";
        }

        public int compareTo(IntIntPair o) {
            int value = Integer.compare(first, o.first);
            if (value != 0) {
                return value;
            }
            return Integer.compare(second, o.second);
        }
    }
    static class Pair<U, V> implements Comparable<Pair<U, V>> {
        public final U first;
        public final V second;

        public static <U, V> Pair<U, V> makePair(U first, V second) {
            return new Pair<U, V>(first, second);
        }

        private Pair(U first, V second) {
            this.first = first;
            this.second = second;
        }

        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Pair pair = (Pair) o;
            return !(first != null ? !first.equals(pair.first) : pair.first != null) &&
                    !(second != null ? !second.equals(pair.second) : pair.second != null);
        }

        public int hashCode() {
            int result = first != null ? first.hashCode() : 0;
            result = 31 * result + (second != null ? second.hashCode() : 0);
            return result;
        }

        public String toString() {
            return "(" + first + "," + second + ")";
        }

        public int compareTo(Pair<U, V> o) {
            int value = ((Comparable<U>) first).compareTo(o.first);
            if (value != 0) {
                return value;
            }
            return ((Comparable<V>) second).compareTo(o.second);
        }
    }
    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 readInt() {
            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 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 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 printLine() {
            writer.println();
        }

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

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

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