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 ProblemSolving.codeforces713;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class D_upsolving {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer("");

        //b를 정렬해서 젤 큰 값 또는 2번째로 큰 값이 합이 되는건데
        // 젤 큰 값이 합이라면 1~n+1 사이 값 중 하나는 빼줘야 하는 거고 -> iterate
        //2번째로 큰 값이 합이라면 쓰레기 값은 가장 큰 값이 되는거고

        int tc= Integer.parseInt(br.readLine());
        for(int tt=0;tt<tc;tt++){
            int n=Integer.parseInt(br.readLine());
            st = new StringTokenizer(br.readLine());
            List<Long> b = new ArrayList<>();
            //LinkedList<Integer> b = new LinkedList<>();
            while(st.hasMoreTokens()) b.add(Long.parseLong(st.nextToken()));
            
            b.sort(Long::compareTo);
            long mx =b.get(n+1);
            long mx2nd =b.get(n);

            long tot=b.stream().reduce(0L,Long::sum);

//            List<Integer> answer = new ArrayList<>();
            boolean found=false;

            //case 1 : 젤 큰 값이 합
            for(int i=0;i<n+1;i++){
                long here= b.get(i);
                if(tot-here-mx==mx){
                    found=true;
                    for(int j=0;j<n+1;j++){
                        if(j==i) continue;
                        System.out.print(b.get(j)+" ");
                    }
                    System.out.println();

                    break;
                }
            }
            if(found) continue;

            //case 2: 2번째 큰 값이 합
            if(tot-mx-mx2nd ==mx2nd){
                //found=true;
                for(int i=0;i<n;i++) System.out.print(b.get(i)+" ");
                System.out.println();
                continue;
            }

            //if(found) continue;

            System.out.println(-1);

        }

    }
}
