You are given a number $n$ and an array $b_1, b_2, \ldots, b_{n+2}$, obtained according to the following algorithm:

some array $a_1, a_2, \ldots, a_n$ was guessed;

array $a$ was written to array $b$, i.e. $b_i = a_i$ ($1 \le i \le 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+\ldots+a_n$;

The $(n+2)$-th element of the array $b$ was written some number $x$ ($1 \le x \le 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 \le t \le 10^4$). Then $t$ test cases follow.

The first line of each test case contains a single integer $n$ ($1 \le n \le 2 \cdot 10^5$).

The second row of each test case contains $n+2$ integers $b_1, b_2, \ldots, b_{n+2}$ ($1 \le b_i \le 10^9$).

It is guaranteed that the sum of $n$ over all test cases does not exceed $2 \cdot 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, \ldots, a_n$, otherwise.

If there are several arrays of $a$, you can output any.


-----Examples-----

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


-----Note-----

None

Difficulty: EASY

Solutions:
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353

def inp():
	return stdin.readline().strip()

def iinp():
	return int(inp())

def out(var, end='\n'):
	stdout.write(str(var) + '\n')

def outa(*var, end='\n'):
	stdout.write(' '.join(map(str, var)) + end)

def lmp():
	return list(mp())

def mp():
	return map(int, inp().split())

def smp():
	return map(str, inp().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(m, val) for j in range(n)]

def remadd(x, y):
	return 1 if x % y else 0

def ceil(a, b):
	return (a + b - 1) // b

def isprime(x):
	if x <= 1:
		return False
	if x in (2, 3):
		return True
	if x % 2 == 0:
		return False
	for i in range(3, int(sqrt(x)) + 1, 2):
		if x % i == 0:
			return False
	return True
for _ in range(int(inp())):
	n = iinp()
	arr = lmp()
	arr.sort()
	sm = sum(arr[:n + 1])
	flg = False
	for i in range(n + 1):
		if i < n and sm - arr[i] == arr[-1] or (i == n and sm - arr[i] in [arr[-1], arr[-2]]):
			flg = True
			break
	if flg:
		for j in range(n + 1):
			if j == i:
				continue
			print(arr[j], end=' ')
		print()
	else:
		print(-1)


t = int(input())
for i in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	a.sort()
	a.reverse()
	sumA = sum(a[1:])
	sumA2 = sum(a[2:])
	checker = False
	checker2 = False
	for k in range(1, len(a)):
		if sumA - a[k] == a[0]:
			res = a[1:k] + a[k + 1:]
			res.sort()
			checker = True
			break
	if checker:
		ausgabe = ''
		for k in res:
			ausgabe += str(k) + ' '
		print(ausgabe)
	elif sumA2 == a[1]:
		res = a[2:]
		res.sort()
		ausgabe = ''
		for k in res:
			ausgabe += str(k) + ' '
		print(ausgabe)
	else:
		print(-1)


def b(d, t, l, h):
	if l > h:
		return None
	else:
		mid = int((l + h) / 2)
		if d[mid] == t:
			return mid
		elif d[mid] > t:
			return b(d, t, l, mid - 1)
		else:
			return b(d, t, mid + 1, h)
for _ in range(int(input())):
	n = int(input())
	l = sorted(map(int, input().split()))
	t = sum(l)
	for i in range(n + 2):
		p = t - l[i]
		if p % 2 == 0:
			j = int(p / 2)
			k = b(l, j, 0, n + 1)
			if k and k != i:
				for a in range(n + 2):
					if a != i and a != k:
						print(l[a], end=' ')
				print()
				n = -1
				break
	if n != -1:
		print(-1)


import sys, math
import heapq
from collections import deque
input = sys.stdin.readline

def ip():
	return int(input())

def fp():
	return float(input())

def sp():
	return str(input().rstrip())

def mip():
	return map(int, input().split())

def msp():
	return map(str, input().split())

def lmip():
	return list(map(int, input().split()))

def lmsp():
	return list(map(str, input().split()))

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	return x * y // gcd(x, y)

def isprime(x):
	if x == 1:
		return False
	for i in range(2, int(x ** 0.5) + 1):
		if x % i == 0:
			return False
	return True

def find(x):
	if x == p[x]:
		return x
	q = find(p[x])
	p[x] = q
	return q

def union(x, y):
	global n
	x = find(x)
	y = find(y)
	if x != y:
		p[y] = x
t = ip()
while t:
	t -= 1
	n = ip()
	b = lmip()
	b.sort()
	sp = sum(b)
	sum1 = sp - b[-1]
	tr = -1
	for i in range(n + 1):
		if sum1 - b[i] == b[-1]:
			tr = i
			break
	if tr < 0:
		if sum(b[:-2]) == b[-2]:
			for i in range(n):
				print(b[i], end=' ')
			print()
			continue
		print(-1)
		continue
	for i in range(n + 1):
		if tr == i:
			continue
		print(b[i], end=' ')
	print()


from collections import Counter
for _ in range(int(input())):
	n = int(input())
	n += 2
	l = list(map(int, input().split()))
	l.sort()
	k = sum(l[0:n - 1])
	if n == 1 or n == 2:
		print(*l)
	else:
		t = -1
		for i in range(n - 1):
			k -= l[i]
			if k == l[-1]:
				t = i
				break
			if i == n - 2:
				if k == l[-2]:
					t = i
					break
			k += l[i]
		if t != -1:
			for i in range(n - 1):
				if i != t:
					print(l[i], end=' ')
			print()
		else:
			print(-1)


from collections import Counter as count
from bisect import bisect
import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
for i in range(int(input())):
	n = int(input())
	z = list(map(int, input().split()))
	z.sort()
	(a, b) = (n, n + 1)
	s = sum(z)
	ans = False
	for i in range(n + 2):
		if s - z[i] - z[a] == z[a] and i != a:
			ss = [z[i], z[a]]
			ans = True
			break
		elif s - z[i] - z[b] == z[b] and i != b:
			ss = [z[i], z[b]]
			ans = True
			break
	if ans and len(ss) == 2:
		for i in z:
			if i in ss:
				ss.remove(i)
			else:
				print(i, end=' ')
		print()
	else:
		print(-1)


t = int(input())

def eee(L, n):
	L.sort()
	c = sum(L)
	if c - 2 * L[-1] in L and L.index(c - 2 * L[-1]) != n + 1:
		i = L.index(c - 2 * L[-1])
		li = []
		for k in range(n + 2):
			if k != i and k != n + 1:
				li.append(L[k])
		return li
	if L[-2] == c - L[-2] - L[-1]:
		return L[0:n]
	return [-1]
for loop in range(t):
	n = int(input())
	L = [int(x) for x in input().split()]
	final = eee(L, n)
	if final == [-1]:
		print(-1)
	else:
		for element in final:
			print(element, end=' ')
		print()