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.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;


public class Main {

    static void solve() {
        Scanner scan = new Scanner(System.in);
        int t = scan.nextInt();
        int cnt = 0;
//        for(int i = 1;i<=100;i++) {
//            for(int j = 1;j<=100;j++) {
//                String[] arr = new String[] {String.valueOf(i), String.valueOf(j)};
//                cnt++;
//                solveCaseA(2, arr, cnt + 1);
//            }
//        }
        for (int i = 0; i < t; i++) {
            int n = scan.nextInt();
            int[] arr = new int[n + 2];
            for (int j = 0; j < n + 2; j++) {
                arr[j] = scan.nextInt();
            }
            solveCaseA(arr);
        }
    }

    static void solveCaseA(int[] arr) {
//       Arrays.sort(arr);
        int g;
        int gi;
        int ggi;
        int gg;

        if(arr[0] < arr[1]) {
            g = arr[0];
            gi = 0;
            gg = arr[1];
            ggi = 1;
        } else {
            g = arr[1];
            gi = 1;
            gg = arr[0];
            ggi = 0;
        }

       long sum = arr[0]+arr[1];
        for (int i = 2; i < arr.length; i++) {
            if(arr[i] > g) {
                if(arr[i] < gg) {
                    g = arr[i];
                    gi = i;
                } else {
                    g = gg;
                    gi = ggi;
                     gg = arr[i];
                     ggi = i;
                }
            }
            sum += arr[i];
        }
       // check last el
        long sum1 = sum - arr[ggi];
       int i = 0;
        while(i<arr.length) {
            //check all subsums of n-2 elements == last el (exlcude last + one more)
            if(i == ggi) {
                i++;
                continue;
            }
            sum1-=arr[i];
            if(sum1 == arr[ggi]) {
                //that's the ans, return
                for (int j = 0; j < arr.length; j++) {
                    if(j == ggi || j == i) {
                        continue;
                    }
                    System.out.print(arr[j] + " ");
                }
                System.out.println();
                return;
            }
            sum1+=arr[i];
            i++;
        }

        //check pre-last el
        i = 0;
        long sum2 = sum - arr[gi];
        while(i<arr.length) {
            //check all subsums of n-2 elements == pre last el (exlcude pre last + one more)
            if(i == gi) {
                i++;
                continue;
            }
            sum2-=arr[i];
            if(sum2 == arr[gi]) {
                //that's the ans, return
                for (int j = 0; j < arr.length; j++) {
                    if(j == gi || j == i) {
                        continue;
                    }
                    System.out.print(arr[j] + " ");
                }
                System.out.println();
                return;
            }
            sum2+=arr[i];
            i++;
        }

        System.out.println(-1);
//        System.out.println(String.format("Case #%s: %d", c, ans));
    }

    public static void main(String[] args) {
//        System.out.println();
        solve();

//        int[] arr = new int[] {1,2,3,4,5};
//        int r = 3;
//        int n = arr.length;
//        printCombinations(arr, n, r);

    }

    static class Pair {
        int beg;
        int end;

        public Pair(int beg, int end) {
            this.beg = beg;
            this.end = end;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Pair)) return false;
            Pair pair = (Pair) o;
            return beg == pair.beg &&
                    end == pair.end;
        }

        @Override
        public int hashCode() {
            return Objects.hash(beg, end);
        }
    }

    static class Comp implements Comparator<Pair> {

        @Override
        public int compare(Pair p1, Pair p2) {
            if (p1.beg < p2.beg) {
                return -1;
            }
            if (p1.beg > p2.beg) {
                return 1;
            }
            if (p1.end < p2.end) {
                return -1;
            }
            if (p1.end > p2.end) {
                return 1;
            }
            return 0;
        }
    }

    //    static class TreeNode {
//        int val;
//        TreeNode left;
//        TreeNode right;
//
//        TreeNode(int x) {
//            val = x;
//        }
//    }

    static class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }
//    class Point implements Comparable<Point> {
//        int x;
//        int y;
//        Point(int x, int y) {
//            this.x = x;
//            this.y = y;
//        }
//
//        @Override
//        public int compareTo(Point o) {
//            double dist1 = Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
//            double dist2 = Math.sqrt(Math.pow(o, 2) + Math.pow(o.y, 2));
//            if(dist1 < dist2) {
//                return 1;
//            }
//            if(dist1 > dist2) {
//                return -1;
//            }
//            return 0;
//        }
//    }

}