Problem: This is an interactive problem.

Ayush devised a new scheme to set the password of his lock. The lock has k slots where each slot can hold integers from 1 to n. The password P is a sequence of k integers each in the range [1, n], i-th element of which goes into the i-th slot of the lock.

To set the password of his lock, Ayush comes up with an array A of n integers each in the range [1, n] (not necessarily distinct). He then picks k non-empty mutually disjoint subsets of indices S_1, S_2, ..., S_k (S_i \underset{i ≠ j} ∩ S_j = ∅) and sets his password as P_i = max_{j ∉ S_i} A[j]. In other words, the i-th integer in the password is equal to the maximum over all elements of A whose indices do not belong to S_i.

You are given the subsets of indices chosen by Ayush. You need to guess the password. To make a query, you can choose a non-empty subset of indices of the array and ask the maximum of all elements of the array with index in this subset. You can ask no more than 12 queries.

Input

The first line of the input contains a single integer t (1 ≤ t ≤ 10) — the number of test cases. The description of the test cases follows.

The first line of each test case contains two integers n and k (2 ≤ n ≤ 1000, 1 ≤ k ≤ n) — the size of the array and the number of subsets. k lines follow. The i-th line contains an integer c (1 ≤ c < n) — the size of subset S_i, followed by c distinct integers in the range [1, n] — indices from the subset S_i.

It is guaranteed that the intersection of any two subsets is empty.

Interaction

To ask a query print a single line: 

  * In the beginning print "? c " (without quotes) where c (1 ≤ c ≤ n) denotes the size of the subset of indices being queried, followed by c distinct space-separated integers in the range [1, n]. 



For each query, you will receive an integer x — the maximum of value in the array among all the indices queried. If the subset of indices queried is invalid or you exceeded the number of queries (for example one of the indices is greater than n) then you will get x = -1. In this case, you should terminate the program immediately.

When you have guessed the password, print a single line "! " (without quotes), followed by k space-separated integers — the password sequence.

Guessing the password does not count towards the number of queries asked.

After this, you should read a string. If you guess the password correctly, you will receive the string "Correct". In this case, you should continue solving the remaining test cases. If the guessed password is incorrect, you will receive the string "Incorrect". In this case, you should terminate the program immediately.

The interactor is not adaptive. The array A does not change with queries.

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.



Hacks

To hack the solution use the following test format:

The first line of the input should contain a single integer t (1 ≤ t ≤ 10) — the number of test cases. 

The first line of each test case should contain two integers n and k (2 ≤ n ≤ 1000, 1 ≤ k ≤ n) — the size of the array and the number of subsets. The next line should consist of n space separated integers in the range [1, n] — the array A. k lines should follow. The i-th line should contain an integer c (1 ≤ c < n) — the size of subset S_i, followed by c distinct integers in the range [1, n] — indices from the subset S_i.

The intersection of any two subsets has to be empty.

Example

Input


1
4 2
2 1 3
2 2 4

1

2

3

4

Correct

Output


? 1 1

? 1 2

? 1 3

? 1 4

! 4 3

Note

The array A in the example is [1, 2, 3, 4]. The length of the password is 2. The first element of the password is the maximum of A[2], A[4] (since the first subset contains indices 1 and 3, we take maximum over remaining indices). The second element of the password is the maximum of A[1], A[3] (since the second subset contains indices 2, 4).

Do not forget to read the string "Correct" / "Incorrect" after guessing the password.

Solution (in JAVA):

Solution:
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.stream.IntStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.function.Function;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Map;
import java.io.OutputStreamWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.Collection;
import java.util.Set;
import java.io.IOException;
import java.util.stream.Collectors;
import java.util.List;
import java.util.stream.Stream;
import java.io.Writer;
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);
        DGuessTheMaximums solver = new DGuessTheMaximums();
        solver.solve(1, in, out);
        out.close();
    }

    static class DGuessTheMaximums {
        private Map<Set<Integer>, Integer> cache;

        public void solve(int testNumber, InputReader in, OutputWriter out) {
            cache = new HashMap<>();
            int t = in.nextInt();
            for (int i = 0; i < t; i++) {
                try {
                    slv(i, in, out);
                } catch (Exception e) {
                    throw e;
//                break;
                }
            }
        }

        private void slv(int tnum, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            int otherVal;
            int maxNodVal;
            List<List<Integer>> subs = new ArrayList<>();
            List<Integer> otherList = new ArrayList<>();
            boolean[] others = new boolean[n + 1];
            for (int i = 0; i < k; i++) {
                int c = in.nextInt();
                int[] tArr = in.nextIntArray(c);
                for (int val : tArr) {
                    try {
                        others[val] = true;
                    } catch (Exception e) {
                        throw new DGuessTheMaximums.FInnerOne();
                    }
                }
                subs.add(Arrays.stream(tArr).boxed().collect(Collectors.toList()));
            }
            try {
                for (int i = 1; i <= n; i++) {
                    if (!others[i]) {
                        otherList.add(i);
                    }
                }
            } catch (Exception e) {
                throw new DGuessTheMaximums.FInnerTwo();
            }

            try {
                otherVal = -1;
//            otherVal = (otherList.size() > 0) ? query(otherList, in, out) : -1;
                maxNodVal = query(subs.stream().flatMap(List::stream).collect(Collectors.toList()), in, out);
            } catch (Exception e) {
                throw new DGuessTheMaximums.SecondException();
            }
            if (otherVal >= maxNodVal) {
                int[] ans = new int[k];
                for (int i = 0; i < k; i++) {
                    ans[i] = otherVal;
                }
                output(ans, in, out);
            } else {
                int mxInd;
                try {
                    Function<Integer, Boolean> func =
                            ind -> (query(subs.subList(0, ind + 1).stream().flatMap(List::stream)
                                    .collect(Collectors.toList()), in, out) == maxNodVal);
                    if (k > 1) {
                        mxInd = BinarySearch.searchFirstOne(0, k, func);
                    } else {
                        mxInd = 0;
                    }
                } catch (Exception e) {
                    throw new DGuessTheMaximums.ThirdException();
                }
                if (mxInd == k) {
                    throw new RuntimeException("Unexpected state. max val node is not found in array");
                }
                int[] ans = new int[k];
                try {
                    if (k != 1) {
                        List<Integer> allOtherNodes = IntStream.range(0, k).filter(y -> (y != mxInd)).boxed().map(subs::get)
                                .flatMap(List::stream).collect(Collectors.toList());
                        List<Integer> nq = Stream.concat(allOtherNodes.stream(), otherList.stream())
                                .collect(Collectors.toList());
                        int otherAns = query(nq, in, out);
                        if (otherAns > maxNodVal) {
                            for (int i = 0; i < k; i++) {
                                ans[i] = otherAns;
                            }
                        } else {
//                        mxAns = Math.max(query(nq, in, out), otherVal);
                            for (int i = 0; i < k; i++) {
                                if (i != mxInd) {
                                    ans[i] = maxNodVal;
                                }
                            }
                            ans[mxInd] = otherAns;
                        }
                    } else {
                        int otherAns = query(otherList, in, out);
                        ans[0] = otherAns;
//                    if (otherAns > maxNodVal) {
//                        for (int i = 0; i < k; i++) {
//                            ans[i] = otherAns;
//                        }
//                    } else {
////                        mxAns = Math.max(query(nq, in, out), otherVal);
//                        for (int i = 0; i < k; i++) {
//                            if (i != mxInd) {
//                                ans[i] = maxNodVal;
//                            }
//                        }
//                        ans[mxInd] = otherAns;
//                    }
//                    mxAns = otherVal;
                    }
//                for (int i = 0; i < k; i++) {
//                    if (i != mxInd) {
//                        ans[i] = maxNodVal;
//                    }
//                }
//                ans[mxInd] = mxAns;
                    output(ans, in, out);
                } catch (Exception e) {
                    throw new DGuessTheMaximums.FourthException();
                }
            }
            cache.clear();
        }

        private int query(List<Integer> sub, InputReader in, OutputWriter out) {
            Set<Integer> st = new HashSet<>(sub);
            if (cache.containsKey(st)) {
                return cache.get(st);
            }
            int c = sub.size();
            out.print("? " + c);
            for (int val : sub) {
                out.print(" " + val);
            }
            out.println();
            out.println();
            out.flush();

            int x = in.nextInt();
            cache.put(st, x);
            if (x == -1) {
                throw new RuntimeException("x == -1 received");
            }

            return x;
        }

        private void output(int[] password, InputReader in, OutputWriter out) {
            out.print("!");
            for (int val : password) {
                out.print(" " + val);
            }
            out.println();
//        out.println();
            out.flush();

            String outcome = in.nextString();
            if (outcome.equals("Incorrect")) {
                throw new RuntimeException("Incorrect assertion");
            }
        }

        private static class SecondException extends RuntimeException {
        }

        private static class ThirdException extends RuntimeException {
        }

        private static class FourthException extends RuntimeException {
        }

        private static class FInnerOne extends RuntimeException {
        }

        private static class FInnerTwo extends RuntimeException {
        }

    }

    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 int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; ++i) array[i] = nextInt();
            return array;
        }

        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 println() {
            writer.println();
        }

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

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

    }

    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;
            }
        }

    }
}