You are given a number n and an array b_1, b_2, …, b_{n+2}, obtained according to the following algorithm: 

  * some array a_1, a_2, …, a_n was guessed; 
  * array a was written to array b, i.e. b_i = a_i (1 ≤ i ≤ n); 
  * The (n+1)-th element of the array b is the sum of the numbers in the array a, i.e. b_{n+1} = a_1+a_2+…+a_n; 
  * The (n+2)-th element of the array b was written some number x (1 ≤ x ≤ 10^9), i.e. b_{n+2} = x; The 
  * array b was shuffled. 



For example, the array b=[2, 3, 7, 12 ,2] it could be obtained in the following ways: 

  * a=[2, 2, 3] and x=12; 
  * a=[3, 2, 7] and x=2. 



For the given array b, find any array a that could have been guessed initially.

Input

The first line contains a single integer t (1 ≤ t ≤ 10^4). Then t test cases follow.

The first line of each test case contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5).

The second row of each test case contains n+2 integers b_1, b_2, …, b_{n+2} (1 ≤ b_i ≤ 10^9).

It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.

Output

For each test case, output: 

  * "-1", if the array b could not be obtained from any array a; 
  * n integers a_1, a_2, …, a_n, otherwise. 



If there are several arrays of a, you can output any.

Example

Input


4
3
2 3 7 12 2
4
9 1 7 1 6 5
5
18 2 2 3 2 9 2
3
2 6 9 2 1


Output


2 3 7 
-1
2 2 2 3 9 
1 2 6 
import java.util.*;
import java.io.*;
public class Main {
    static Scanner in =new Scanner(System.in);
    static final Random random=new Random();
    static int mod=1000_000_007;
    static int []rank;
    static List<List<Integer>>adj;
    public static void main(String[] args) {
    int tt=in.nextInt();//in.nextLine();
           outer:while(tt-->0) {
               int n=in.nextInt();long sum=0;long x1=0;
               long a[]=readAr(n+2);
               Map<Long,Long>map=new HashMap<>();
               for(long x:a){
                   sum+=x;
                   map.put(x,map.getOrDefault(x,(long)0)+1);
               }
               // for(int x:map.keySet()){
               //     System.out.print(x+" ");
               // }
              // System.out.println(sum);
               boolean fy=true,fx=true;
               for(int i=0;i<n+2;i++){
                   long y=a[i];
                   map.put(y,map.getOrDefault(y,(long)0)-1);
                   if((sum-y)%2 ==0){
                       x1=(sum-y)/2;
                     // System.out.println(x1+" "+y+" "+map.containsKey((int)x1));
                       if(map.containsKey(x1) && map.get(x1)>0){
                          for(long x:a){
                              if(x==y && fy){fy=false;continue;}
                              if(x==x1 && fx){fx=false;continue;}
                              System.out.print(x+" ");
                          }
                           System.out.println();
                           continue outer;
                       }
                   }
                   map.put(y,map.getOrDefault(y,(long)0)+1);
               }
               System.out.println(-1);
       }
    }
    
    static long sum(long n){
        long res=0;
        while(n>0){
            res+=(n%10);n/=10;
        }
        return res;
    }
    static void uf (int[] root, int v1, int v2) {
            int rootP = find(v1,root);
            int rootQ = find(v2,root);
            if (rootP == rootQ) return;
            if (rank[rootQ] > rank[rootP]) {
                root[rootP] = rootQ;
                rank[rootQ]+=rank[rootP];
                rank[rootP]=0;
            }
            else {
                root[rootQ] = rootP;
                rank[rootP]+=rank[rootQ];
                rank[rootQ]=0;
            }
    }
    static int find(int p,int [] root) {
        	while (p != root[p]) {
               root[p] =root[root[p]];
                p = root[p];
            }
            return p;
        }
    static int nCr(int n,int r,int p){
        if (r == 0) return 1; 
        if(r==1)return n;
        return ((int)fact(n)*modInverse((int)fact(r),p)%p * modInverse((int)fact(n-r),p) % p)%p; 
    }
    static int modInverse(int n, int p){ 
        return power(n, p-2, p); 
    } 
    static int power(int x,int y,int p){ 
        int res = 1;
        x= x % p;
        while (y>0){
            if (y%2==1) 
                res= (res*x)% p;
            y= y >> 1;
            x= (x*x)% p; 
        }
        return res; 
    } 
    static void seive(){
        int num=1000001;
        boolean[] prime = new boolean[num];
        Arrays.fill(prime,true);
        for (int i=2; i*i<=num; i++) {
            if(prime[i] == true) {
                for(int j=i*i; j<num; j=j+i) {
                   prime[j]=false;
                }
            }
        }
    }
    static long[]readAr(int n) {
        long[] a=new long[(int)n];
        for (int i=0; i<n; i++) {a[i]=in.nextLong();}
        return a;
	}
    static int[]readA1r(int n) {
        int[] a=new int[(int)n];
        for (int i=0; i<n; i++) {a[i]=in.nextInt();}
        return a;
	}
    static int fact(int k){
        long[]f=new long[10001];f[1]=1;
        for(int i=2;i<10001;i++){
            f[i]=(i*f[i-1]% mod);
        }
        return (int)f[k];
    }
	static void ruffleSort(int[] a) {
		int n=a.length;
		for (int i=0; i<n; i++) {
			int oi=random.nextInt(n), temp=a[oi];
			a[oi]=a[i]; a[i]=temp;
		}
		Arrays.sort(a);
	}
	static void reverse(int []a){
        int n= a.length;
        for(int i=0;i<n/2;i++){
            int temp=a[i];
            a[i]=a[n-i-1];
            a[n-i-1]=temp;
            a[i]=a[i];
        }
        //debug(a);
	}
	static void debug(int []a) {
        for (int i=0; i<a.length;i++) System.out.print(a[i]+" ");
        System.out.println();
	}
	static void print(List<Integer>s) {
        for(int x:s) System.out.print(x+",");
        System.out.println();
	}
	static long gcd(long a, long b) {
        return (b==0) ? a : gcd(b, a % b);
	}
    static long find_max(long []a){
        long m=Integer.MIN_VALUE;
        for(long x:a)m=Math.max(x,m);
        return m;
    }
    static int find_min(int []a){
        int m=Integer.MAX_VALUE;
        for(int x:a)m=Math.min(x,m);
        return m;
    }
}