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.io.File;

import java.io.FileNotFoundException;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
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.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class D {
	static final Random random = new Random();
	static int size = 0;
	static List<Integer> ans = new ArrayList<>();

	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;
		}
		ArrayList<Integer> lst = new ArrayList<>();
		for (int i : a)
			lst.add(i);
		Collections.sort(lst);
		for (int i = 0; i < n; i++)
			a[i] = lst.get(i);
	}

	static void ruffleSort(long[] a) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			int oi = random.nextInt(n);
			long temp = a[oi];
			a[oi] = a[i];
			a[i] = temp;
		}
		ArrayList<Long> lst = new ArrayList<>();
		for (long i : a)
			lst.add(i);
		Collections.sort(lst);
		for (int i = 0; i < n; i++)
			a[i] = lst.get(i);
	}
	public static void process() throws IOException {
		int n = ii();
		long[] a = ial(n+2);
		long B=0;
		ruffleSort(a);
		for(int i=0;i<n;i++) {
			B+=a[i];
		}
		if(B==a[n]) {
			for(int i=0;i<n;i++) {
				System.out.print(a[i]+" ");
			}
			System.out.println();
			return;
		}
		B+=a[n];
		int x=-1;
		for(int i=0;i<n+1;i++) {
			if(B-a[i]==a[n+1]) {
				x=i;
				break;
			}
		}
		if(x==-1) {
			System.out.println(-1);
			return;
		}
//		System.out.print("A = "+A+" ");
		for(int i=0;i<n+1;i++) {
			if(i!=x) {
				System.out.print(a[i]+" ");
			}
		}
		System.out.println();
	}

	static AnotherReader sc;
	static PrintWriter out;

	public static void main(String[] args) throws IOException {
		boolean oj = System.getProperty("ONLINE_JUDGE") != null;
		if (oj) {
			sc = new AnotherReader();
			out = new PrintWriter(System.out);
		} else {
			sc = new AnotherReader(100);
			out = new PrintWriter("output.txt");
		}
		long s = System.currentTimeMillis();
		int t = 1;
        t=ii();
		int k = 0;
		while (t-- > 0) {
			process();
		}
		out.flush();
		System.err.println(System.currentTimeMillis() - s + "ms");
		out.close();
	}

	static long power(long k, long c, long mod) {
		long y = 1;
		while (c > 0) {
			if (c % 2 == 1)
				y = y * k % mod;
			c = c / 2;
			k = k * k % mod;
		}
		return y;
	}

	static void pn(Object o) {
		out.println(o);
	}

	static void p(Object o) {
		out.print(o);
	}

	static void pni(Object o) {
		out.println(o);
		out.flush();
	}

	static int ii() throws IOException {
		return sc.nextInt();
	}

	static long il() throws IOException {
		return sc.nextLong();
	}

	static double id() throws IOException {
		return sc.nextDouble();
	}

	static String iln() throws IOException {
		return sc.nextLine();
	}

	static int[] iai(int N) throws IOException {
		int[] A = new int[N];
		for (int i = 0; i != N; i++) {
			A[i] = ii();
		}
		return A;
	}

	static long[] ial(int N) throws IOException {
		long[] A = new long[N];
		for (int i = 0; i != N; i++) {
			A[i] = il();
		}
		return A;
	}

	static long gcd(long a, long b) throws IOException {
		return (b == 0) ? a : gcd(b, a % b);
	}

	static int gcd(int a, int b) throws IOException {
		return (b == 0) ? a : gcd(b, a % b);
	}

	static int bit(long n) throws IOException {
		return (n == 0) ? 0 : (1 + bit(n & (n - 1)));
	}

	/////////////////////////////////////////////////////////////////////////////////////////////////////////

	static class AnotherReader {
		BufferedReader br;
		StringTokenizer st;

		AnotherReader() throws FileNotFoundException {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		AnotherReader(int a) throws FileNotFoundException {
			br = new BufferedReader(new FileReader("C:\\Users\\Utkarsh\\OneDrive\\Desktop\\input1.txt"));
		}

		String next() throws IOException {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() throws IOException {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

	/////////////////////////////////////////////////////////////////////////////////////////////////////////////
}
