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:
import java.util.*;
import java.io.*;
public class D {
  private static PrintWriter out;
  private static FS sc;
  private static class FS {
    StringTokenizer st;
    BufferedReader br;
    public FS() {
      br = new BufferedReader(new InputStreamReader(System.in));
    }
    public String next() {
      while (st == null || !st.hasMoreElements()) {
        try {st = new StringTokenizer(br.readLine());}
        catch (IOException e) {e.printStackTrace();}
      }
      return st.nextToken();
    }
    public String nextLine() {
      String s = null;
      try {s = br.readLine();}
      catch (IOException e) {e.printStackTrace();}
      return s;
    }
    public int nextInt() {return Integer.parseInt(next());}
    public long nextLong() {return Long.parseLong(next());}
    public double nextDouble() {return Double.parseDouble(next());}
  }
  
  public static void main(String[] args) {
    sc = new FS();
    out = new PrintWriter(new BufferedOutputStream(System.out));
    int t = sc.nextInt();
    while (t-- > 0) {
		int n = sc.nextInt();
		long sum = 0;
		int[] b = new int[n+2];
		Map<Integer, Integer> m = new HashMap<>();
		for (int i = 0; i < n + 2; ++i) {
			b[i] = sc.nextInt();
			m.put(b[i],m.getOrDefault(b[i], 0) + 1);
			sum += b[i];
		}
		int x = -1, y = -1;
		for (int i = 0; i < n + 2; ++i) {
			long s = sum - b[i];
			m.put(b[i], m.get(b[i])-1);
			if ((s&1) == 0 && (s >> 1) <= (int)1e9) {
				int v = (int) (s >> 1);
				if (m.getOrDefault(v, 0) > 0) {
				x = b[i];
				y = (int)(s >> 1);
				break;
				}
			}
			m.put(b[i], m.get(b[i]) + 1);
		}
		if (x == -1) out.println(-1);
		else {
			for (int a : b) {
				if (a == x) {x = -1;}
				else if (a == y) {y = -1;}
				else out.print(a+" ");
			}
			out.println();
		}
    }
    out.close();
  }
}