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 
//package codeforces._713;

import java.io.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;

public class _D {

    public static void main (String[] args) throws Exception {

//        String s = "4\n" +
//                "3\n" +
//                "2 3 7 12 2\n" +
//                "4\n" +
//                "9 1 7 1 6 5\n" +
//                "5\n" +
//                "18 2 2 3 2 9 2\n" +
//                "3\n" +
//                "2 6 9 2 1";

        String s = "1\n" +
                "2\n" +
                "8 4 4 4\n";


//        2 3 7
//                -1
//        2 2 2 3 9
//        1 2 6

//        br = new BufferedReader(new StringReader(s));
        br = new BufferedReader(new InputStreamReader(System.in));
        bw = new BufferedWriter(new OutputStreamWriter(System.out));

        rl(); int T = nin();
        next_test:
        for (int t=1; t<=T; ++t) {
            rl(); int n=nin();
            long[] b = new long[n+2];
            HashMap<Long, Integer> map = new HashMap<>();
            long sum = 0;
            rl(); for (int i=0; i<n+2; ++i) {
                long v=nlo();
                b[i]=v;
                sum +=v;
                if (!map.containsKey(v)) map.put(v,1); else map.put(v, map.get(v)+1);
            }

            next:
            for (int i=0; i<n+2; ++i) {
                long x = sum-(b[i]*2);
                if (map.containsKey(x)) {
                    if (x==b[i] && map.get(x)==1) continue next;
                    StringBuffer a = new StringBuffer();
                    boolean gotx = false;
                    for (int j=0; j<n+2; ++j) {
                        if (j==i) continue;
                        if (b[j]==x && !gotx) {
                            gotx=true;
                            continue;
                        }
                        a.append(b[j]+" ");
                    }
                    bw.write( a+"\n");
                    continue next_test;
                }
            }

            bw.write( "-1\n");

        }
        bw.flush();
    }

    static BufferedReader br; static BufferedWriter bw; static StringTokenizer st;
    static void rl() throws Exception{ st = new StringTokenizer(br.readLine()); }
    static long nlo(){ return Long.parseLong(st.nextToken()); }
    static int nin(){ return Integer.parseInt(st.nextToken()); }
    /*private static void te(){}*/
    static double ndo(){ return Double.parseDouble(st.nextToken()); }
    static char[] nca(){ return st.nextToken().toCharArray(); }
}
