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 CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

#define F first
#define S second
#define pb push_back 
#define mp make_pair

#define ll long long 
#define ld long double 

#define vi vector <int>
#define vb vector <bool>
#define vc vector <char>
#define vll vector <ll>
#define vs vector <string>

#define pll pair < ll , ll >
#define pld pair < ld , ld >
#define pii pair < int , int >

#define vpld vector < pld >
#define vpii vector < pii >
#define vpll vector < pll >

#define vvi vector < vector < int > >
#define vvll vector < vector < ll > >
#define vvld vector < vector < ld > >
#define vvb vector < vector < bool > >
#define vvpii vector < vector < pii > >
//vector<vector<int>> v(n, vector<int>(n));

#define all(v) (v).begin() , (v).end()
#define allrev(v) (v).rbegin() , (v).rend()

#define dist(x1 , y1 , x2 , y2) sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1))

const int MOD = 1e9 + 7 ;

//------------------------------------------------------------------------------------------------------------------------------------

bool isprime (ll num) {
    for (ll i = 2 ; i * i <= num ; ++i) {
		if (num % i == 0) return false ;
	}
    return true;
}
 
ll gcd (ll a, ll b) {
    if (b == 0) return a ;
	else return gcd (b , a % b) ;
}
 
ll lcm (ll a, ll b) {
    return ((a / gcd(a , b)) * b) ;
}
 
ll cel (ll x1, ll y1) {
    if ((x1) <= 0) return (x1) / (y1) ;
    return (((x1) / (y1)) + (((x1) % (y1)) != 0)) ;
}

void swap(ll int &a,ll int &b){
    a=a^b;
	b^=a;
	a^=b;
}

void givesubsequence(string s){
    int n=s.size();
	int numberofsubsequence=(1<<n)-1;
	for(int i=1;i<=numberofsubsequence;i++){
	    int temp=i,j=0;
	    while(temp>0){
	        if(temp&1) cout<<s[j];
	        j++;
	        temp=temp>>1;
	    }
	    cout<<endl;
	}
}

float squareRoot(float n) 
    { 
        float x = n; 
        float y = 1; 
        float e = 0.000001;
        while (x - y > e) { 
            x = (x + y) / 2; 
            y = n / x; 
        } 
        return x; 
    } 
    
void search(string pat, string txt)  
{  
    int M = pat.size();  
    int N = txt.size();  
    int i = 0;  
  
    while (i <= N - M)  
    {  
        int j;
        for (j = 0; j < M; j++)  
            if (txt[i + j] != pat[j])  
                break;  
        if (j == M) 
        {  
            cout << "Pattern found at index " << i << endl;  
            i = i + M;  
        }  
        else if (j == 0)  
            i = i + 1;  
        else
            i = i + j;  
    }  
}  
    
int power(int x, unsigned int y) 
{ 
    if (y == 0) 
        return 1; 
    else if (y%2 == 0) 
        return power(x, y/2)*power(x, y/2); 
    else
        return x*power(x, y/2)*power(x, y/2); 
} 
/*int INT(string s)
{
    return stoi(s);
}*/

int sum_of_digits(long long n) {
	int res = 0;
	while (n > 0) {
		res += n % 10;
		n /= 10;
	}
	return res;
}

//------------------------------------------------------------------------------------------------------------------------------------------------
int isPalindrome(string str)
{
    int l = 0;
    int h = str.size() - 1;
    while (h > l)
    {
        if (str[l++] != str[h--])
        return 0;
    }
    return 1;
}

void solve (int test_case) {
	int n;
	cin>>n;
	n+=2;
	ll int a[n],sum=0;
	for(int i=0;i<n;i++) cin>>a[i],sum+=a[i];
	sort(a,a+n);
	sum-=(a[n-1]+a[n-2]);
	if(sum==a[n-1]||sum==a[n-2]){
	    for(int i=0;i<n-2;i++) cout<<a[i]<<' ';
	    cout<<endl;
	    return;
	}
	sum+=a[n-2];
	ll int left=sum-a[n-1];
	if(left<=0) {cout<<-1<<endl; return;}
	int b=-1;
	for(int i=0;i<n-1;i++){
	    if(left==a[i]) {b=i; break;}
	}
	if(b==-1) {cout<<-1<<endl; return;}
	for(int i=0;i<n-1;i++){
	    if(i!=b) cout<<a[i]<<' ';
	}
	cout<<endl;
}

int main() {
	ios_base :: sync_with_stdio (false) ;
	cin.tie(0) ;
	cout.tie(0) ;
	//freopen("input.txt","r",stdin);
    //freopen("output.txt","w",stdout);
	int tc = 1 ;
	cin >> tc ;
	while (tc--) {
		solve (tc) ;
	}
	return 0 ;
}