Problem: 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 

Solution (in JAVA):

Solution:
/*
    JAI MATA DI
 */

import java.util.*;

//import javax.print.attribute.HashAttributeSet;

import java.io.*;
import java.math.BigInteger;
import java.sql.Array;

public class CP {
	  static class FR{
			BufferedReader br;
			StringTokenizer st;
			public FR() {
				br = new BufferedReader(new InputStreamReader(System.in));
			}
			String next() 
		    { 
		        while (st == null || !st.hasMoreElements()) 
		        { 
		            try
		            { 
		                st = new StringTokenizer(br.readLine()); 
		            } 
		            catch (IOException  e) 
		            { 
		                e.printStackTrace(); 
		            } 
		        } 
		        return st.nextToken(); 
		    } 

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

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

		    double nextDouble() 
		    { 
		        return Double.parseDouble(next()); 
		    } 

		    String nextLine() 
		    { 
		        String str = ""; 
		        try
		        { 
		            str = br.readLine(); 
		        } 
		        catch (IOException e) 
		        { 
		            e.printStackTrace(); 
		        } 
		        return str; 
		    } 
		}
	 static int mod  = 1000000007;
	 static long gcd(long a, long b)
	  {      
	     if (b == 0)
	        return a;
	     return gcd(b, a % b); 
	  }
	 static boolean[] prime(int num) {
			boolean[] bool = new boolean[num];
		     
		      for (int i = 0; i< bool.length; i++) {
		         bool[i] = true;
		      }
		      for (int i = 2; i< Math.sqrt(num); i++) {
		         if(bool[i] == true) {
		            for(int j = (i*i); j<num; j = j+i) {
		               bool[j] = false;
		            }
		         }
		      }
		      if(num >= 0) {
		    	  bool[0] = false;
		    	  bool[1] = false;
		      }
		      
		      return bool;
		}
	 static class Pair implements Comparable<Pair>{
		 	int x;
	 		int y;
	 		Pair(int key , int value){
	 			this.x = key;
	 			this.y = value;
	 		}
			@Override
			public int compareTo(Pair o) {
				return this.x - o.x;
			}
//			@Override
//			public int hashCode(){
//				return val + ind;
//			}
	 	}
	 	
	
	 public static void main(String args[]) {
		 
		 FR sc = new FR();
		 int tc = sc.nextInt();
		 StringBuilder sb = new StringBuilder();
		 while(tc-- > 0) {
				
				int n = sc.nextInt();
				ArrayList<Long> al = new ArrayList<>();
				for(int i = 0 ; i<n+2 ; i++) {
					al.add(sc.nextLong());
				}
				long sum = 0;
				int ind = -1;
				Collections.sort(al);
				for(int i = 0 ;i<n ; i++) sum += al.get(i);

				if(sum == al.get(n)) {
					for(int i = 0 ; i<n ; i++) {
						sb.append(al.get(i)+" ");
						}
					sb.append("\n");
				}else {
					sum += al.get(n); 
					for(int i = 0 ; i<=n ;i++) {
						if(sum - al.get(i) == al.get(n+1)) {
							ind = i;
							break;
						}
					}
					if(ind == -1) {
						sb.append("-1\n");
					}else {
						for(int i = 0 ; i<=n ; i++) {
							if(i !=ind) {
								sb.append(al.get(i)+" ");
							}
						}sb.append("\n");
					}
					
				}
				
				
				}
		 System.out.println(sb);
	    }
	
	 	
	 }