Problem: Note that the only difference between the easy and hard version is the constraint on the number of queries. You can make hacks only if all versions of the problem are solved.

This is an interactive problem.

You are given a tree consisting of n nodes numbered with integers from 1 to n. Ayush and Ashish chose two secret distinct nodes in the tree. You need to find out both the nodes. You can make the following query: 

  * Provide a list of nodes and you will receive a node from that list whose sum of distances to both the hidden nodes is minimal (if there are multiple such nodes in the list, you will receive any one of them). You will also get the sum of distances of that node to the hidden nodes. 



Recall that a tree is a connected graph without cycles. The distance between two nodes is defined as the number of edges in the simple path between them.

More formally, let's define two hidden nodes as s and f. In one query you can provide the set of nodes \\{a_1, a_2, …, a_c\} of the tree. As a result, you will get two numbers a_i and dist(a_i, s) + dist(a_i, f). The node a_i is any node from the provided set, for which the number dist(a_i, s) + dist(a_i, f) is minimal.

You can ask no more than 14 queries.

Input

The first line contains a single integer t (1 ≤ t ≤ 10) — the number of test cases. Please note, how the interaction process is organized.

The first line of each test case consists of a single integer n (2 ≤ n ≤ 1000) — the number of nodes in the tree.

The next n - 1 lines consist of two integers u, v (1 ≤ u, v ≤ n, u ≠ v) — the edges of the tree.

Interaction

To ask a query print a single line: 

  * In the beginning print "? c " (without quotes) where c (1 ≤ c ≤ n) denotes the number of nodes being queried, followed by c distinct integers in the range [1, n] — the indices of nodes from the list. 



For each query, you will receive two integers x, d — the node (among the queried nodes) with the minimum sum of distances to the hidden nodes and the sum of distances from that node to the hidden nodes. If the subset of nodes queried is invalid or you exceeded the number of queries then you will get x = d = -1. In this case, you should terminate the program immediately.

When you have guessed the hidden nodes, print a single line "! " (without quotes), followed by two integers in the range [1, n] — the hidden nodes. You can output the hidden nodes in any order.

After this, you should read a string. If you guess the nodes correctly, you will receive the string "Correct". In this case, you should continue solving the remaining test cases or terminate the program, if all test cases were solved. Otherwise, you will receive the string "Incorrect". In this case, you should terminate the program immediately.

Guessing the hidden nodes does not count towards the number of queries asked.

The interactor is not adaptive. The hidden nodes do not change with queries.

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

You need to solve each test case before receiving the input for the next test case.

The limit of 14 queries applies to each test case and not to the entire input.

After printing a query do not forget to output the end of the 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 the documentation for other languages.



Hacks

To hack the solution, use the following test format:

The first line should contain 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 should contain a single integer n (2 ≤ n ≤ 1000) — the number of nodes in the tree. The second line should contain two distinct integers in the range [1, n] — the hidden nodes. The next n - 1 lines should contain two integers u, v (1 ≤ u, v ≤ n, u ≠ v) — the edges of the tree.

Example

Input


1
3
1 2
1 3

1 1

2 3

3 1

3 1

Correct

Output


? 1 1

? 1 2

? 1 3

? 2 2 3

! 1 3

Note

The tree from the first test is shown below, and the hidden nodes are 1 and 3.

<image>

Solution (in JAVA):

Solution:

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.StringTokenizer;



public class COVID {

	static ArrayList<Integer>[] adjList;






	static int[] fac;
	static int mod=998244353;
	static int pow(int b,long e) {
		int ans=1;
		while(e>0) {
			if((e&1)==1)
				ans=(int)((ans*1l*b));
			e>>=1;
			b=(int)((b*1l*b));
		}
		return ans;
	}

	static int powmod(int b,long e, int mod) {
		int ans=1;
		b%=mod;
		while(e>0) {
			if((e&1)==1)
				ans=(int)((ans*1l*b)%mod);
			e>>=1;
			b=(int)((b*1l*b)%mod);
		}
		return ans;
	}

	static int oneUnqiue(int[] arr) {
		int one=0;int two=0;
		for(int i=0;i<arr.length;i++) {
			two|=(one&arr[i]);
			one^=arr[i];
			int turnOff=~(one&two);
			two&=turnOff;
			one&=turnOff;

		}
		return one;
	}




	public static long check(long a, long k)
	{
		if(k==1)return a;
		long tmp=a;
		int min=10;
		int max=-1;
		while(tmp!=0) {
			int dig=(int)(a%10);
			min=Math.min(dig, min);
			max=Math.max(dig, max);
			tmp/=10;
		}
		return check(a+min*max,k-1);
	}
	ArrayList<Pair> arr;
	static int idx;

	public static boolean moreThanOne(char[] a, char[] b) {
		int c=0;
		for(int i=0;i<a.length;i++)
			if(a[i]!=b[i]) {
				c++;
				if(c>1)return true;
			}
		return false;
	}
	static int[][] grid;

	static int n,m,a,b;
	static int[] col;

	static Scanner sc;
	static PrintWriter pw;
	static int[] cost,pre,pos;
	public static void main(String[] args) throws Exception {
				sc = new Scanner(System.in);
				 int t=sc.nextInt();
				while(t-->0) {
					int n=sc.nextInt();
					int k=sc.nextInt();
					HashSet<Integer>[] S=new HashSet[k];
					for(int i=0;i<k;i++) {
						int c=sc.nextInt();
						S[i]=new HashSet<>();
						for(int j=0;j<c;j++)
							S[i].add(sc.nextInt());
					}
				
					int max=query(n, 1, n);
					if(max==-1)return;
					int lo=1;
					int hi=n;
					while(lo<hi) {
						int mid=lo+hi>>1;
						int q=query(mid-lo+1, lo, mid);
						if(q==-1)return;
						if(q==max) {
							hi=mid;
						}else {
							lo=mid+1;
						}
					}
					HashSet<Integer> set=new HashSet<>();
					ArrayList<Integer> list=new ArrayList<>();
					int idx=-1;
					for(int i=0;i<k;i++) {
						if(S[i].contains(lo)) {
							set=S[i];
							idx=i;
							break;
						}
					}
					for(int i=1;i<=n;i++) {
						if(!set.contains(i))
						list.add(i);
					}
					StringBuilder sb=new StringBuilder();
					
				sb.append("? "+list.size());
					for(int i=0;i<list.size();i++) {
						sb.append(" "+list.get(i));
					}
					System.out.println(sb.toString());
					
					
					int rep=sc.nextInt();
					if(rep==-1)return;
					sb=new StringBuilder();
					sb.append("!");
					for(int i=0;i<k;i++) {
						if(i==idx)
							sb.append(" "+rep);
						else {
							sb.append(" "+max);
						}
					}
					System.out.println(sb.toString());
					
					String s=sc.next();
					if(!s.equals("Correct"))break;
				}

	}
	static long INF=(long)(1e16);
	static long[] memo;

	public static void  sum(int n) {
		vis[n]=true;
		for(int v:adjList[n])
			if(!vis[v])
			{
				sum(v);
				pre[n]+=pre[v];
				pos[n]+=pos[v];
			}
	}
	public static int query(int size,int from , int to) throws IOException {
		StringBuilder sb=new StringBuilder();
		sb.append("? "+size);
		for(int i=from;i<=to;i++) {
			sb.append(" "+i);
		}
		System.out.println(sb.toString());
		return sc.nextInt();
	}
	static int[] deg;
	static boolean[]vis;
	static int  dfs(int n) {
		if(vis[n])return 0;
		vis[n]=true;
		int ans=deg[n];
		for(int v:adjList[n])
			if(!vis[v])
				ans+=dfs(v);
		return ans;
	}

	static int bs(int[] a, int val) {
		int l=0;
		int h=a.length-1;
		while(l<=h) {
			int mid=(l+h+1)>>1;
		if(a[mid]>=val)
			h=mid-1;
		else
			l=mid+1;
		}
		return h+1;
	}


	static boolean[] isPrime;
	static ArrayList<Integer> primes;
	public static void sieve(int N) {// O( n log( log n ) )
		isPrime= new boolean[N+1];//u can save half the memory by neglecting all even numbers since they aren't primes
		primes= new ArrayList<>(N);
		Arrays.fill(isPrime, true);
		isPrime[0]=isPrime[1]=false;
		for(int i=2;i*i<=N;i++) {
			if(isPrime[i]) {
				for(int j=i*i;j<=N;j+=i) {
					isPrime[j]=false;
				}
			}
		}
		for(int i=2;i<=N;i++) {
			if(isPrime[i])primes.add(i);
		}
	}

	static long gcd(long a, long b) {
		return (b==0)?a:gcd(b,a%b);
	}
	static long lcm(long a, long b) {
		return a/gcd(a,b)*b;
	}
	public static int log(int n , int base) {
		int ans=0;
		while(n+1>base) {
			ans++;
			n/=base;
		}
		return ans;
	}
	static long square(long l) {
		return l*l;
	}






	static class Pair implements Comparable<Pair>{
		int  x;int y;

		public Pair(int a,int b) {
			this.x=a;y=b;
		}



		public int compareTo(Pair o) {
			return (x==o.x)?((y>o.y)?1:(y==o.y)?0:-1):((x>o.x)?1:-1);
		}


		@Override

		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + x;
			result = prime * result + y;
			return result;
		}


		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Pair other = (Pair) obj;
			if (x != other.x)
				return false;
			if (y != other.y)
				return false;
			return true;
		}

	}





	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}
		public Scanner(String s) throws FileNotFoundException{	br = new BufferedReader(new FileReader(s));}

		public long[] nextLongArr(int n) throws IOException {
			long[] arr=new long[n];
			for(int i=0;i<n;i++)
				arr[i]=nextLong();
			return arr;
		}
		public int[] nextIntArr(int n) throws IOException {
			int[] arr=new int[n];
			for(int i=0;i<n;i++)
				arr[i]=nextInt();
			return arr;
		}
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine()," ,");
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}


		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++) {
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
				if (sb.length() == 18) {
					res += Long.parseLong(sb.toString()) / f;
					sb = new StringBuilder("0");
				}
			}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

	public static void shuffle(int[] a) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			int r = i + (int) (Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
	}
}