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 Solution {
 
    static PrintWriter pr = new PrintWriter(System.out);
    static Scanner sc = new Scanner(System.in);
 
    public static void main(String[] args) {
        int tests = sc.nextInt();
 
        for (int x = 0; x < tests; x++) {
            int N = sc.nextInt();
            long[] arr = new long[N + 2];
            for (int y = 0; y < (N + 2); y++) {
                arr[y] = sc.nextLong();
            }
            getRes(arr, N);
        }
 
        pr.flush();
    }
 
    static void getRes(long[] arr, int N) {
        long[] res = new long[N + 1];
        long totSum = 0, max = -1, smax = -1, uniq = -1, tot = -1;
 
        for (int x = 0; x < N + 2; x++) {
            totSum += arr[x];
            if (arr[x] > max) {
                smax = max;
                max = arr[x];
            } else if (arr[x] > smax)
                smax = arr[x];
        }
 
        if ((totSum - smax - smax - max) == 0) {
            uniq = max;
            tot = smax;
        }
        else {
            uniq = totSum - max - max;
            tot = max;
        }
 
        int ct = 0, uniqi = -1, toti = -1;
 
        for (int x = 0; x < N+2; x++) {
            if (toti == -1 && arr[x] == tot)
                toti = x;
            if (arr[x] == uniq)
                uniqi = x;
        }
 
        if (toti == -1 || uniqi == -1 || toti == uniqi) {
            pr.println("-1");
            return;
        }
 
        for (int x = 0; x < N + 2; x++) {
            if (x != uniqi && x != toti)
                res[ct++] = arr[x];
        }
 
        for (int x = 0; x < N; x++) {
            pr.print(res[x] + " ");
        }
        pr.println();
    }
}