You are given a sequence $b_1, b_2, \ldots, b_n$. Find the lexicographically minimal permutation $a_1, a_2, \ldots, a_{2n}$ such that $b_i = \min(a_{2i-1}, a_{2i})$, or determine that it is impossible.


-----Input-----

Each test contains one or more test cases. The first line contains the number of test cases $t$ ($1 \le t \le 100$).

The first line of each test case consists of one integer $n$ — the number of elements in the sequence $b$ ($1 \le n \le 100$).

The second line of each test case consists of $n$ different integers $b_1, \ldots, b_n$ — elements of the sequence $b$ ($1 \le b_i \le 2n$).

It is guaranteed that the sum of $n$ by all test cases doesn't exceed $100$.


-----Output-----

For each test case, if there is no appropriate permutation, print one number $-1$.

Otherwise, print $2n$ integers $a_1, \ldots, a_{2n}$ — required lexicographically minimal permutation of numbers from $1$ to $2n$.


-----Example-----
Input
5
1
1
2
4 1
3
4 1 3
4
2 3 4 5
5
1 5 7 2 8

Output
1 2 
-1
4 5 1 2 3 6 
-1
1 3 5 6 7 9 2 4 8 10

Difficulty: EASY
Tags: Greedy algorithms
Skill types: Greedy algorithms

Starter code:

Solutions:
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	if 2 * n in b:
		print(-1)
		continue
	arr = [0 for i in range(2 * n)]
	for i in b:
		arr[i - 1] = 1
	res = []
	for i in b:
		res.append(i)
		k = i
		while k < 2 * n:
			if arr[k] == 0:
				res.append(k + 1)
				arr[k] = 1
				break
			k += 1
	if len(res) < 2 * n:
		print(-1)
	else:
		for i in res:
			print(i, end=' ')
		print()


for t in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0] * (2 * n + 1)
	res = []
	f = True
	for i in b:
		a[i] = 1
	for i in b:
		res.append(i)
		val = 0
		for j in range(i, 2 * n + 1):
			if a[j] != 1:
				val = j
				break
		if val == 0:
			f = False
			break
		a[val] = 1
		res.append(val)
	if f:
		print(*res)
	else:
		print(-1)


from sys import stdin
from math import sqrt, factorial, ceil
from collections import Counter, defaultdict
from heapq import heapify, heapreplace, heappush, heappop
from bisect import bisect_left
t = int(stdin.readline())
while t:
	t -= 1
	n = int(stdin.readline())
	b = list(map(int, stdin.readline().split()))
	a = [0] * (2 * n)
	j = 0
	r = [0] * (2 * n + 1)
	ans = 1
	for i in range(0, 2 * n, 2):
		a[i] = b[j]
		j += 1
		r[a[i]] = 1
	for i in range(1, 2 * n, 2):
		temp = a[i - 1] + 1
		while temp <= 2 * n:
			if r[temp] == 0:
				a[i] = temp
				r[temp] = 1
				break
			temp += 1
		if a[i] == 0:
			ans = -1
			break
	if ans == 1:
		print(*a)
	else:
		print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	c = [0] * (2 * n)
	d = []
	for i in range(0, 2 * n, 2):
		c[i] = b[i // 2]
	for j in range(1, 2 * n + 1):
		if j not in c:
			d.append(j)
	for i in range(n):
		for j in range(0, 2 * n, 2):
			if c[j + 1] == 0:
				if d[i] > c[j]:
					c[j + 1] = d[i]
					break
	if 0 in c:
		print('-1')
	else:
		print(*c)


for _ in ' ' * int(input()):
	a = int(input())
	if a == 1:
		z = int(input())
		if z == 1:
			print('1 2')
		else:
			print(-1)
		continue
	b = list(map(int, input().split()))
	if 1 not in b or 2 * a in b:
		print(-1)
		continue
	c = [i for i in range(1, 2 * a + 1) if i not in b]
	r = []
	for i in range(a):
		for j in c:
			if j > b[i]:
				r += [j]
				c.remove(j)
				break
	if len(r) != a:
		print(-1)
	else:
		for i in range(a):
			print(b[i], r[i], end=' ')
		print()


def solve():
	n = eval(input())
	b = input().split()
	vis = [0 for i in range(0, 420)]
	a = [0 for i in range(0, 400)]
	pos = 0
	flag = True
	for x in b:
		vis[int(x)] = 1
	for x in b:
		y = int(x)
		pos += 1
		a[2 * pos - 1] = y
		ok = False
		for j in range(y + 1, 2 * n + 1):
			if vis[j] == 0:
				vis[j] = 1
				a[pos * 2] = j
				ok = True
				break
		if ok == False:
			flag = False
			break
	if flag == False:
		print(-1)
	else:
		for i in range(1, 2 * n + 1):
			print(a[i], end=' ')
		print('')
t = eval(input())
while t:
	solve()
	t -= 1


import os
import sys
from io import BytesIO, IOBase
import threading
from collections import Counter
mod = 998244353

def main():
	for _ in range(int(input())):
		n = int(input())
		arr = list(map(int, input().split()))
		a = list(zip(arr, range(1, n + 1)))
		a.reverse()
		taken = [0] * (2 * n + 1)
		ans = [-1] * (2 * n + 1)
		for i in range(n):
			taken[arr[i]] = 1
		b = True
		while len(a):
			(ele, ind) = a.pop()
			el2 = -1
			for i in range(ele + 1, 2 * n + 1):
				if taken[i] == 0:
					el2 = i
					break
			if el2 == -1:
				b = False
				break
			else:
				taken[el2] = 1
				ans[2 * ind - 1] = ele
				ans[2 * ind] = el2
		if b:
			print(*ans[1:])
		else:
			print(-1)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


t = int(input())
for i in range(0, t):
	o = []
	n = int(input())
	l = list(map(int, input().split()))
	e = 0
	for j in range(0, len(l)):
		o.append(l[j])
		c = l[j] + 1
		if c > 2 * n:
			e = 1
			break
		else:
			while c in l or c in o:
				c += 1
				if c > 2 * n:
					e = 1
					break
		if e == 1:
			break
		o.append(c)
	if e == 1:
		print(-1)
	else:
		for k in range(0, len(o)):
			print(o[k], end=' ')
		print()


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
from collections import *
ORDA = 97

def ii():
	return int(input())

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

def li():
	return [int(i) for i in input().split()]

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=2):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	new_number = 0
	while number > 0:
		new_number += number % base
		number //= base
	return new_number

def cdiv(n, k):
	return n // k + (n % k != 0)

def ispal(s):
	for i in range(len(s) // 2 + 1):
		if s[i] != s[-i - 1]:
			return False
	return True

def function(arr, size, dp):
	if size == 1 or size == 0:
		return 1
	key = ''.join(map(str, arr[:size]))
	if dp[key]:
		return dp[key]
	output = function(arr, size - 1, dp)
	key = ''.join(map(str, arr[:size - 1]))
	dp[key] = output
	if arr[size - 2] * 10 + arr[size - 1] <= 26:
		output += function(arr, size - 2, dp)
		key = ''.join(map(str, arr[:size - 2]))
		dp[key] = output
	return output

def main():
	for _ in range(ii()):
		n = ii()
		arr = li()
		b = [0] * 2 * n
		d = [True] * (2 * n + 1)
		i = 0
		for ele in arr:
			d[ele] = False
			b[i] = ele
			i += 2
		ok = True
		for i in range(1, 2 * n, 2):
			e = b[i - 1] + 1
			while e <= 2 * n:
				if d[e]:
					d[e] = False
					b[i] = e
					break
				e += 1
			else:
				ok = False
				break
		if ok:
			print(*b)
		else:
			print(-1)
main()


import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
tests = inp()
testcount = 0
while testcount < tests:
	n = inp()
	b = inlt()
	if 1 not in b or 2 * n in b:
		print(-1)
	else:
		arr = []
		for elem in b:
			i = 1
			while i < 4 * n:
				if elem + i not in b and elem + i not in arr:
					arr.append(elem + i)
					i += 4 * n
				else:
					i += 1
		string = ''
		i = 0
		while i < n:
			string += str(b[i]) + ' ' + str(arr[i]) + ' '
			i += 1
		if max(max(b), max(arr)) > 2 * n:
			print(-1)
		else:
			print(string[:len(string) - 1])
	testcount += 1


t = int(input())
for _ in range(t):
	n = int(input())
	a = [i for i in range(1, 2 * n + 1)]
	m = [int(i) for i in input().split()]
	l = []
	for e in m:
		k = e
		l.append(k)
		while True:
			e = e + 1
			if e not in m and e not in l:
				l.append(e)
				break
	q = l.copy()
	q.sort()
	if q == a:
		print(*l)
	else:
		print(-1)


t = int(input())
for test in range(t):
	n = int(input())
	b = [int(i) for i in input().split()]

	def solve():

		def minimal(v):
			for i in perm:
				if i > v:
					return perm.pop(perm.index(i))
			return v
		perm = list(range(1, n * 2 + 1))
		for i in range(n * 2 - 1, -1, -1):
			if perm[i] in b:
				del perm[i]
		msg = ''
		for v in b:
			msg += str(v) + ' '
			iplus = minimal(v)
			if iplus > v:
				msg += str(iplus) + ' '
			else:
				return '-1'
		return msg
	print(solve())


def solve(n, b):
	if 1 not in b or 2 * n in b:
		return [-1]
	else:
		s = set(b)
		arr = []
		for i in range(n):
			j = b[i] + 1
			while True:
				if j not in s and j <= 2 * n:
					arr.append(j)
					s.add(j)
					break
				elif j > 2 * n:
					return [-1]
				j += 1
		return [str(b[x]) + ' ' + str(arr[x]) for x in range(n)]
for _ in range(int(input())):
	n = int(input())
	b = [int(x) for x in input().split()]
	print(*solve(n, b))


import bisect
t = int(input())
for i in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l1 = []
	l2 = []
	c = 0
	l3 = sorted(l)
	for i in range(min(l) + 1, 2 * n + 1):
		if i not in l:
			l1.append(i)
	if len(l1) == 0:
		print(-1)
	else:
		for i in l:
			if len(l1) == 0:
				c += 1
				break
			w = bisect.bisect_left(l1, i)
			if w == len(l1):
				c += 1
				break
			l2.append(i)
			l2.append(l1[w])
			del l1[w]
		if c == 0:
			print(*l2)
		else:
			print(-1)


import sys
input = lambda : sys.stdin.readline().rstrip()

def last_proverka(v):
	for i in range(len(v)):
		i += 1
		if i not in v:
			return -1
	return True

def l_proverka(v, c):
	for i in range(len(c)):
		if v[i] == c[i]:
			return False
	return True

def x(m, sr):
	for i in range(1000):
		if i > sr and i not in m and (i not in a):
			return i
	return False
for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0] * 2 * n
	for i in range(n):
		a[2 * i] = b[i]
	k = True
	for i in range(2 * n):
		if a[i] == 0:
			c = x(b, a[i - 1])
			if c == False:
				k = False
				break
			else:
				a[i] = c
	if last_proverka(a) == True:
		print(*a)
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = [-1] * 2 * n
	for x in range(1, 2 * n + 1):
		if x in b:
			i = 2 * b.index(x)
			a[i] = x
		else:
			i = -1
			for j in range(0, 2 * n, 2):
				if a[j] != -1 and a[j] < x and (a[j + 1] == -1):
					i = j
					break
			if i != -1:
				a[i + 1] = x
	if any(map((-1).__eq__, a)):
		print(-1)
	else:
		print(*a)


for t in range(int(input())):
	n = int(input())
	l = [int(i) for i in input().split()]
	visited = [0 for i in range(2 * n)]
	res = []
	for i in l:
		visited[i - 1] = 1
	for i in l:
		temp = i
		while temp < 2 * n and visited[temp]:
			temp += 1
		if temp >= 2 * n:
			res = [-1]
			break
		visited[temp] = 1
		res.append(i)
		res.append(temp + 1)
	print(*res)


testCases = int(input())
for i1 in range(testCases):
	length = int(input())
	taken = [False] * length * 2
	b = list(map(int, input().split()))
	a = [0] * 2 * length
	for i2 in range(length):
		taken[b[i2] - 1] = True
		a[i2 * 2] = b[i2]
	if taken.index(True) > 0:
		print(-1)
	else:
		for i2 in range(length):
			for i3 in range(b[i2], 2 * length, 1):
				if not taken[i3]:
					taken[i3] = True
					a[i2 * 2 + 1] = i3 + 1
					break
		if 0 in a:
			print(-1)
		else:
			for i2 in a:
				print(i2, end=' ')
			print('')


for _ in range(int(input())):
	n = int(input())
	A = list(map(int, input().split()))
	mark = []
	C = []
	for i in A:
		m = i + 1
		while True:
			if m in A or m in C:
				m += 1
			else:
				break
		mark.append(i)
		mark.append(m)
		C.append(m)
	Ans = []
	jaya = mark.copy()
	jaya.sort()
	for i in range(1, 2 * n + 1):
		Ans.append(i)
	if jaya == Ans:
		print(*mark)
	else:
		print(-1)


import sys
input = sys.stdin.readline
(t,) = map(int, input().split())
for _ in range(t):
	N = int(input())
	B = list(map(int, input().split()))
	vs = set(B)
	cc = 0
	for i in range(2 * N, 0, -1):
		if i in vs:
			cc -= 1
		else:
			cc += 1
		if cc < 0:
			print(-1)
			break
	else:
		rs = []
		for b in B:
			rs.append(b)
			for i in range(b + 1, 2 * N + 1):
				if i not in vs:
					rs.append(i)
					vs.add(i)
					break
		print(*rs)


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	ans = []
	for i in b:
		ans.append(i)
		t = i + 1
		while t in b or t in ans:
			t += 1
		ans.append(t)
	if max(ans) == 2 * n:
		print(*ans)
	else:
		print('-1')


def solve(m, b):
	d = dict()
	y = dict()
	for i in range(m):
		d[b[i]] = 0
	for k in d.keys():
		x = k + 1
		while x in d.keys() or x in y.keys():
			x += 1
		if x > 2 * m:
			return -1
		d[k] = x
		y[x] = k
	for i in range(m):
		print(b[i], d[b[i]], end=' ')
	print()
	return 1
for _ in range(int(input())):
	m = int(input())
	b = list(map(int, input().split()))
	if solve(m, b) == -1:
		print(-1)


import sys
from collections import Counter

def solve(N, B):
	counts = Counter(B)
	if any((v > 1 for v in counts.values())):
		return -1
	C = []
	for x in range(1, 2 * N + 1):
		if x not in counts:
			C.append(x)
	if any((b > c for (b, c) in zip(sorted(B), C))):
		return -1

	def gen(index=0):
		if index == N:
			yield C
			return
		for (c, i) in sorted(zip(C[index:N], range(index, N))):
			if B[index] < c:
				(C[index], C[i]) = (C[i], C[index])
				yield from gen(index + 1)
				(C[index], C[i]) = (C[i], C[index])
	for sol in gen():
		A = []
		for (b, c) in zip(B, C):
			A.append(str(b))
			A.append(str(c))
		return ' '.join(A)
	return -1
input = sys.stdin.readline
T = int(input())
for t in range(T):
	(N,) = map(int, input().split())
	B = [int(x) for x in input().split()]
	ans = solve(N, B)
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	a = [int(x) for x in input().split()]
	b = [None] * (2 * n)
	c = set(a)
	d = set(range(1, 2 * n + 1))
	for i in range(len(a)):
		x = a[i] + 1
		while x in c:
			x += 1
		else:
			q = 2 * i
			w = 2 * i + 1
			b[q] = a[i]
			b[w] = x
			c.add(x)
	count = 1
	if c != d:
		print('-1')
	elif count == 1 or 1:
		for i in range(len(b)):
			print(b[i], end=' ')
		print()


def solve(num, n):
	res = [None] * (2 * n)
	for (i, x) in enumerate(num):
		res[i * 2] = x
	used = set(num)
	for i in range(len(num)):
		for x in range(num[i] + 1, 2 * n + 1):
			if x not in used:
				used.add(x)
				res[2 * i + 1] = x
				break
	return ' '.join([str(x) for x in res]) if None not in res else -1
n = int(input())
for _ in range(n):
	l = int(input())
	num = list(map(int, input().split()))
	print(solve(num, l))


for _ in range(int(input())):
	n = int(input())
	l = [*map(int, input().split())]
	s = set()
	s1 = set(l)
	for i in range(1, 2 * n + 1):
		if i not in s1:
			s.add(i)
	ans = []
	for i in range(n):
		ans.append(l[i])
		for j in range(l[i] + 1, 2 * n + 1, 1):
			if j in s:
				ans.append(j)
				s.remove(j)
				break
	if len(ans) == 2 * n:
		print(*ans)
	else:
		print('-1')


from typing import List
import collections
import bisect
import itertools
import functools
from fractions import gcd
import heapq
from math import ceil, sqrt, floor

def bisect_ceil(A, target):
	low = 0
	high = len(A) - 1
	if not A or A[-1] < target:
		return -1
	if A[0] > target:
		return 0
	while low <= high:
		mid = (low + high) // 2
		midv = A[mid]
		if midv == target:
			return mid
		elif target > midv:
			low = mid + 1
		elif mid - 1 >= 0 and A[mid - 1] < target < A[mid]:
			return mid
		else:
			high = mid - 1
t = int(input())
for _ in range(t):
	n = int(input())
	B = list(map(int, input().split()))
	B_set = set(B)
	candidate = [i for i in range(1, 2 * n + 1) if i not in B_set]
	result = [0] * (2 * n)
	p = ''
	for i in range(n):
		result[2 * i] = B[i]
		index = bisect_ceil(candidate, B[i])
		if index == -1:
			p = '-1'
			break
		result[2 * i + 1] = candidate[index]
		del candidate[index]
	if p:
		print(p)
	else:
		print(' '.join([str(i) for i in result]))


import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 10 ** 9 + 7
EPS = 1e-06

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
for _ in range(Int()):
	n = Int()
	a = array()
	ans = [0] * (2 * n)
	have = []
	ok = True
	for i in range(1, 2 * n + 1):
		if i not in a:
			have.append(i)
	for i in range(n):
		ans[2 * i] = a[i]
		ind = bisect_left(have, a[i])
		try:
			ans[2 * i + 1] = have[ind]
			have.remove(have[ind])
		except:
			ok = False
	if ok:
		print(*ans)
	else:
		print(-1)


import math
import atexit
import io
import sys
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())

def array_to_string(a):
	s = ''
	for i in a:
		s += str(i)
	return s
t = int(input())
while t > 0:
	t = t - 1
	n = int(input())
	b = list(map(int, input().split()))
	temp = [1 for i in range(4 * n)]
	temp = [0] + temp
	a = [0 for i in range(2 * n)]
	for i in range(n):
		temp[b[i]] = 0
		a[2 * i] = b[i]
	for i in range(n):
		num = b[i]
		for j in range(num + 1, len(temp)):
			if temp[j] == 1:
				a[2 * i + 1] = j
				temp[j] = 0
				break
	if max(a) > 2 * n:
		print(-1)
		continue
	for i in a:
		print(i, end=' ')
	print()


def solution():
	for _ in range(int(input())):
		n = int(input())
		arr = [int(i) for i in input().split()]
		maximal = max(arr)
		minimal = min(arr)
		mandatory = set(range(1, minimal + maximal + 1))
		if len(mandatory) > 2 * n or minimal > 1:
			print(-1)
			continue
		if len(mandatory) != 2 * n:
			mandatory.update(set(range(len(mandatory) + 1, 2 * n + 1)))
		mandatory.difference_update(set(arr))
		ans = [0] * n
		for i in range(0, n, 1):
			if arr[i] + 1 in mandatory:
				ans[i] = arr[i] + 1
				mandatory.remove(ans[i])
			else:
				for j in mandatory:
					if j > arr[i]:
						ans[i] = j
						mandatory.remove(j)
						break
		if 0 in ans:
			print(-1)
			continue
		from functools import reduce
		from operator import add
		print(*reduce(add, zip(arr, ans)))
solution()


for nt in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	d = set(b)
	ansflag = 0
	ans = []
	d1 = {}
	for i in range(n):
		ans.append(b[i])
		k = 1
		flag = 0
		while True:
			if b[i] + k > 2 * n:
				flag = 1
				break
			if b[i] + k not in d and b[i] + k not in d1:
				ans.append(b[i] + k)
				d1[b[i] + k] = 1
				break
			else:
				k += 1
		if flag == 1:
			print(-1)
			ansflag = 1
			break
	if ansflag != 1:
		print(*ans)


I = input
for _ in [0] * int(I()):
	I()
	b = (*map(int, I().split()),)
	s = {*range(2 * len(b) + 1)} - {*b}
	a = []
	try:
		for x in b:
			a += (x, min(s - {*range(x)}))
			s -= {*a}
	except:
		a = (-1,)
	print(*a)


for __ in range(int(input())):
	n = int(input())
	b = [-1] * (2 * n)
	a = [int(x) for x in input().split()]
	m1 = {}
	for i in range(n):
		m1[a[i]] = 1
		b[2 * i] = a[i]
	for i in range(1, 2 * n, 2):
		k = a[i // 2]
		while k in m1:
			k += 1
		b[i] = k
		m1[k] = 1
	f = 0
	for x in b:
		if x > 2 * n:
			f = 1
			break
	if f == 1:
		print(-1)
	else:
		for x in b:
			print(x, end=' ')
		print()


t = int(input())
elt = []
for i in range(t):
	n = int(input())
	l = []
	c = []
	chaine = input()
	el = chaine.split(' ')
	for e in el:
		l.append(int(e))
		c.append(int(e))
	elt.append((n, c, l))
for (n, c, l) in elt:
	for k in range(2 * n):
		m = 0
		if k + 1 not in l:
			g = 0
			for p in c:
				if k + 1 > p:
					l.insert(l.index(p) + 1, k + 1)
					c.remove(p)
					g = 1
					break
			if g == 0:
				m = -1
				print(-1)
				break
	if m == 0:
		for g in l:
			print(g, end=' ')
		print('')


from math import *
zzz = int(input())
for zz in range(zzz):
	n = int(input())
	b = [int(i) for i in input().split()]
	a = [0] * (2 * n)
	sl = set([i + 1 for i in range(2 * n)])
	ha = True
	for i in range(n):
		a[2 * i] = b[i]
		try:
			sl.remove(b[i])
		except:
			ha = False
			break
	if ha:
		sl = list(sl)
		sl.sort()
		for i in range(n):
			j = 0
			while j < len(sl) and sl[j] < b[i]:
				j += 1
			if j == len(sl):
				ha = False
				break
			else:
				a[2 * i + 1] = sl.pop(j)
	if ha:
		print(' '.join(map(str, a)))
	else:
		print(-1)


def res(n, l):
	l1 = []
	d = {}
	for j in range(1, 2 * n + 1):
		if j not in l:
			l1.append(j)
	for i in l:
		for j in l1:
			if j > i:
				d[i] = j
				l1.remove(j)
				break
	if len(l1) != 0:
		return False
	else:
		return d
t = int(input())
for i in range(t):
	n = int(input())
	l = [int(x) for x in input().split()]
	x = res(n, l)
	if x == False:
		print('-1')
	else:
		for k in l:
			print(k, x[k], end=' ')
		print('\n')


I = input
exec(int(I()) * 'I();b=*map(int,I().split()),;s={*range(2*len(b)+1)}-{*b};a=[]\ntry:\n for x in b:a+=x,min(s-{*range(x)});s-={*a}\nexcept:a=-1,\nprint(*a);')


def read():
	n = int(input())
	b = list(map(int, input().split()))
	return (n, b)

def solve(n, b):
	a = [0] * 2 * n
	marked = [False] * 2 * n
	for bi in b:
		marked[bi - 1] = True
	for i in range(n):
		a[2 * i] = b[i]
		try:
			next_unmarked = marked.index(False, b[i])
			marked[next_unmarked] = True
			a[2 * i + 1] = next_unmarked + 1
		except ValueError:
			return None
	return a
for t in range(int(input())):
	result = solve(*read())
	if result:
		print(*result)
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	dic = {x: 1 for x in range(1, 2 * n + 1)}
	b = []
	ans = True
	for el in map(int, input().split()):
		if el == 2 * n:
			print(-1)
			ans = False
		dic[el] = 0
		b.append(el)
	if ans:
		if dic[1] == 1:
			print(-1)
			continue
		a = {}
		for el in b:
			i = 1
			while dic[i + el] == 0:
				if i + el >= 2 * n:
					ans = False
					break
				i += 1
			a[el] = i + el
			dic[i + el] = 0
		answ = []
		for el in b:
			answ.extend([el, a[el]])
		if ans:
			print(*answ)
		else:
			print(-1)


def printA(b, n):
	a = []
	if 1 not in b:
		print('-1')
		return
	i = 0
	while i != n:
		curr = b[i]
		if curr not in a:
			a.append(curr)
		nextE = curr + 1
		condN = True
		while condN == True:
			if nextE in b or nextE in a:
				condN = True
			else:
				condN = False
				break
			while nextE in b:
				nextE += 1
			while nextE in a:
				nextE += 1
		a.append(nextE)
		i += 1
	newa = sorted(a)
	for i in range(1, 2 * n + 1):
		if i != newa[i - 1]:
			print('-1')
			return
	print(*a)
t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	printA(b, n)


whatever = int(input())
for i in range(whatever):
	k = int(input())
	bs = list(map(int, input().split()))
	a = [0] * 2 * k
	avail = []
	for t in range(1, 2 * k + 1):
		if t not in bs:
			avail.append(t)
	avail = sorted(avail)
	for l in range(0, 2 * k, 2):
		a[l] = bs[int(l / 2)]
		flag = 0
		for hello in avail:
			if hello > bs[int(l / 2)] and flag == 0:
				a[l + 1] = hello
				avail.remove(hello)
				flag = 1
	if 0 in a:
		print(-1)
	else:
		print(*a)


from math import *
from collections import *
t = int(input())
for y in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	ch = [0 for i in range(2 * n + 1)]
	b = [-1 for i in range(2 * n)]
	for i in range(n):
		ch[a[i]] = 1
		b[2 * i] = a[i]
	flag = 0
	for i in range(0, 2 * n, 2):
		m = -1
		for j in range(b[i], 2 * n + 1):
			if ch[j] == 0:
				ch[j] = 1
				m = j
				break
		if m == -1:
			flag = -1
			break
		b[i + 1] = m
	if flag == -1:
		print(-1)
	else:
		for i in b:
			print(i, end=' ')
		print()


t = int(input())

def closest_greater(num, a):
	for x in range(num, len(a)):
		if a[x] == 1:
			a[x] = 0
			return x
	return -1
while t > 0:
	n = int(input())
	s = input()
	b = ['0']
	b = b + s.split()
	a = [1] * (2 * len(b) - 1)
	flag = 0
	ans = []
	for x in range(1, len(b)):
		a[int(b[x])] -= 1
	for x in range(1, len(b)):
		current = int(b[x])
		ans.append(current)
		nex = closest_greater(current, a)
		if nex == -1:
			flag = 1
			break
		else:
			a[nex] = 0
			ans.append(nex)
	if flag == 1:
		print('-1')
	else:
		for x in ans:
			print(x, end=' ')
	t -= 1


I = input
for _ in [0] * int(I()):
	n = 2 * int(I())
	a = [0] * n
	b = a[::2] = (*map(int, I().split()),)
	c = {*range(n + 1)} - {*b}
	i = 1
	try:
		for x in b:
			y = a[i] = min(c - {*range(x)})
			c -= {y}
			i += 2
	except:
		a = (-1,)
	print(*a)


import sys
import math
import heapq
import collections
fast_reader = sys.stdin.readline
fast_writer = sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i) for i in argv)))
	fast_writer('\n')

def printspace(*argv):
	fast_writer(' '.join((str(i) for i in argv)))
	fast_writer(' ')

def inputnum():
	return int(input())

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

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

def inputstring():
	return [x for x in input()]

def inputstringnum():
	return [ord(x) - ord('a') for x in input()]

def inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
t = int(input())
for q in range(t):
	n = inputnum()
	b = inputlist()
	s = []
	ans = []
	for i in range(1, 2 * n + 1):
		if i not in b:
			s.append(i)
	for i in range(n):
		ans.append(b[i])
		for j in range(n):
			if s[j] > b[i]:
				ans.append(s[j])
				s[j] = -1
				break
	s.sort()
	if s[n - 1] != -1:
		print(-1)
	else:
		print(*ans)


def foo():
	size = int(input())
	b = list(map(int, input().split()))
	d = {}
	biggest = 0
	for i in b:
		d[i] = True
	answer = []
	saved = 0
	c = True
	q = []
	c = True
	for i in b:
		j = 1
		while True:
			if not d.get(i + j):
				d[i + j] = True
				break
			else:
				j += 1
		answer.append(i)
		answer.append(i + j)
		if i + j > 2 * len(b):
			c = False
	if c:
		print(*answer)
	else:
		print(-1)
t = int(input())
for i in range(t):
	foo()


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0] * 1111
	for c in b:
		a[c] = 1
	res = []
	for x in b:
		flag = False
		for j in range(x + 1, 2 * n + 1):
			if a[j] == 0:
				flag = True
				a[j] = 2
				res.append(x)
				res.append(j)
				break
		if not flag:
			res = [-1]
			break
	print(' '.join([str(c) for c in res]))


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = [0 for i in range(2 * n)]
	visited = [False for i in range(2 * n)]
	ind = 0
	for i in range(0, 2 * n, 2):
		ans[i] = arr[ind]
		visited[arr[ind] - 1] = True
		ind += 1
	for i in range(1, 2 * n, 2):
		f = 0
		cur = ans[i - 1]
		for j in range(cur, 2 * n):
			if visited[j] == False:
				visited[j] = True
				f = 1
				ans[i] = j + 1
				break
		if f == 0:
			break
	if f == 0:
		print(-1)
	else:
		print(*ans)


n = int(input())
for i in range(n):
	lena = int(input())
	arr = list(map(int, input().split()))
	rem = [j for j in list(range(1, 2 * lena + 1)) if j not in arr]
	counter = 0
	final = []
	for j in range(lena):
		counter2 = 0
		for k in range(arr[j], 2 * lena + 1):
			if k in rem:
				final.append(arr[j])
				final.append(k)
				rem.remove(k)
				counter2 = 1
				break
		if counter2 == 0:
			print(-1)
			counter = 1
			break
	if counter == 0:
		print(*final)


t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	c = [0 for i in range(2 * n)]
	ans = []
	possible = True
	for j in b:
		c[j - 1] = 1
	for j in b:
		possible2 = False
		for k in range(j, 2 * n):
			if c[k] == 0:
				c[k] = 1
				ans.append(j)
				ans.append(k + 1)
				possible2 = True
				break
		if not possible2:
			possible = False
			break
	if not possible:
		print(-1)
	else:
		print(*ans)


for _ in range(int(input())):
	n = int(input())
	B = list(map(int, input().split()))
	A = [0] * (2 * n)
	A[::2] = B
	X = set(range(1, 2 * n + 1)) - set(B)
	for i in range(n):
		x = B[i] + 1
		while x <= 2 * n:
			if x in X:
				A[2 * i + 1] = x
				X.remove(x)
				break
			x += 1
		else:
			print(-1)
			break
	else:
		print(*A)


n = int(input())
for i in range(n):
	length = int(input())
	b = [int(i) for i in input().split()]
	c = list()
	final = list()
	pool = list()
	var = False
	for j in range(1, 2 * length + 1):
		if j not in b:
			pool.append(j)
	for j in range(len(b)):
		var = False
		for k in range(len(pool)):
			if pool[k] > b[j]:
				var = pool[k]
				c.append(var)
				pool.remove(var)
				var = True
				break
		if not var:
			break
	if not var:
		print(-1)
		continue
	else:
		for j in range(len(b)):
			final.append(b[j])
			final.append(c[j])
		print(' '.join(map(str, final)))


from sys import stdin
import math
from bisect import bisect_right

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

def binSearch(a, d):
	res = bisect_right(a, d)
	if res >= len(a):
		return -1
	else:
		return a[res]
t = int(inp())
for _ in range(t):
	n = int(inp())
	b = [int(x) for x in inp().split()]
	ar = [int(x + 1) for x in range(2 * n) if x + 1 not in b]
	ans = []
	for i in b:
		c = binSearch(ar, i)
		if c == -1:
			print(-1)
			break
		else:
			ar.remove(c)
			ans.append(min(i, c))
			ans.append(max(i, c))
	else:
		print(*ans)


t = int(input())
for i in range(t):
	n = int(input())
	ans = [0] * (2 * n)
	list2 = [True] * (2 * n + 1)
	b = list(map(int, input().split()))
	fin = True
	for (k, j) in enumerate(b):
		ans[2 * k] = j
		list2[j] = False
	for (l, j) in enumerate(b):
		for k in range(j + 1, 2 * n + 1):
			if list2[k] == True:
				list2[k] = False
				ans[2 * l + 1] = k
				break
		else:
			fin = False
			break
	if fin == True:
		print(' '.join(map(str, ans)))
	else:
		print(-1)


n = int(input())
for a in range(n):
	answer = ''
	size = int(input())
	nums = list(map(int, input().split()))
	taken = set(nums)
	possible = True
	if 1 not in taken:
		print(-1)
		continue
	for num in nums:
		answer += str(num) + ' '
		found = False
		for b in range(num + 1, 2 * size + 1):
			if b not in taken:
				found = True
				taken.add(b)
				answer += str(b) + ' '
				break
		if not found:
			possible = False
			break
	if possible:
		print(answer)
	else:
		print(-1)


import sys
queries = int(sys.stdin.readline())
for query in range(queries):
	length = int(sys.stdin.readline())
	arr = [int(x) for x in sys.stdin.readline().strip().split()]
	mx = arr[0]
	ans_arr = [0] * (length * 2)
	arr_ins = [x for x in range(length * 2, 0, -1)]
	for el in arr:
		del arr_ins[arr_ins.index(el)]
	for pos in range(length):
		ans_arr[pos * 2] = arr[pos]
		ins_pos = len(arr_ins) - 1
		while ins_pos >= 0 and arr_ins[ins_pos] < arr[pos]:
			ins_pos -= 1
		if ins_pos == -1:
			ans_arr = ['-1']
			break
		else:
			ans_arr[pos * 2 + 1] = arr_ins[ins_pos]
			del arr_ins[ins_pos]
	print(' '.join(map(str, ans_arr)))


import sys
input = sys.stdin.readline

def fastio():
	from io import StringIO
	from atexit import register
	global input
	sys.stdin = StringIO(sys.stdin.read())
	input = lambda : sys.stdin.readline().rstrip('\r\n')
	sys.stdout = StringIO()
	register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))
fastio()
INF = 10 ** 20
MOD = 998244353
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br
(t,) = I()
while t:
	t -= 1
	(n,) = I()
	a = I()
	ans = [0] * (2 * n)
	v = [0] * (2 * n + 1)
	for i in range(0, 2 * n, 2):
		ans[i] = a[i // 2]
		v[ans[i]] = 1
	for i in range(1, 2 * n, 2):
		cur = ans[i - 1]
		for j in range(1, 2 * n + 1):
			if v[j] == 0 and j > cur:
				v[j] = 1
				ans[i] = j
				break
		else:
			print(-1)
			break
	else:
		print(*ans)


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	a = min(l)
	b = max(l)
	if a != 1 or b == 2 * n:
		print(-1)
	else:
		B = []
		d = dict()
		for i in range(n):
			d.setdefault(l[i], 1)
		for i in range(1, 2 * n + 1):
			d.setdefault(i, 0)
			if d[i] == 0:
				B.append(i)
		B.sort()
		ans = []
		i = 0
		while i < n:
			ans.append(l[i])
			for j in range(len(B)):
				if B[j] > l[i]:
					ans.append(B[j])
					B.pop(j)
					break
			i += 1
		if len(ans) < 2 * n:
			print(-1)
			continue
		print(*ans)


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	sq = []
	bq = [int(b) for b in sys.stdin.readline().split()]
	aq = [True] * (2 * n + 1)
	for b in bq:
		aq[b] = False
	for b in bq:
		sq.append(b)
		j = b + 1
		while j <= 2 * n:
			if aq[j]:
				aq[j] = False
				sq.append(j)
				break
			j += 1
		else:
			print(-1)
			break
	else:
		sys.stdout.write(str(sq[0]))
		for s in sq[1:]:
			sys.stdout.write(' ')
			sys.stdout.write(str(s))
		sys.stdout.write('\n')


for t in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	used = [False] * (n * 2)
	a = []
	for x in b:
		used[x - 1] = True
	for x in b:
		for i in range(x + 1, 2 * n + 1):
			if not used[i - 1]:
				a.append(x)
				a.append(i)
				used[i - 1] = True
				break
		else:
			print(-1)
			break
	else:
		print(*a)


from collections import defaultdict
for _ in range(int(input())):
	N = int(input())
	List = [int(x) for x in input().split()]
	Dict = defaultdict(int)
	for i in List:
		Dict[i] = 1
	Res = []
	flag = 0
	for i in range(N):
		Res.append(List[i])
		if List[i] == 2 * N:
			flag = 1
			print(-1)
			break
		for j in range(List[i] + 1, 2 * N + 1):
			if Dict[j] == 0:
				Res.append(j)
				Dict[j] = 1
				break
			elif j == 2 * N and Dict[j] == 1:
				flag = 1
				print(-1)
				break
		if flag == 1:
			break
	if flag == 0:
		print(*Res)


import sys
import bisect

def metod(x):
	if t[x] == 'A':
		w = a
	else:
		w = b
	for i in range(x + 1, len(t) - 1):
		if t[i] != t[i - 1]:
			if t[i] == 'A':
				w += a
			else:
				w += b
	return w

def morzermorzer():
	n = int(input())
	w = list(map(int, input().split()))
	isk = []
	for i in range(1, 2 * n + 1):
		if i not in w:
			isk.append(i)
	isk.sort()
	ans = [0 for i in range(2 * n)]
	for i in range(n):
		ans[i * 2] = w[i]
	fl = 0
	for i in range(n - 1):
		ind = bisect.bisect(isk, w[i])
		if ind != n - i:
			r = isk[ind]
			del isk[ind]
			ans[i * 2 + 1] = r
		else:
			print(-1)
			return 0
	if isk[-1] < w[-1]:
		print(-1)
		return 0
	else:
		ans[-1] = isk[-1]
		print(*ans)
for morzer in range(int(input())):
	morzermorzer()


t = int(input())
for q in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	marked = [0] * (2 * n + 1)
	for i in range(len(arr)):
		marked[arr[i]] = 1
	ans = []
	for i in range(n):
		ans.append(arr[i])
		for j in range(arr[i] + 1, len(marked)):
			if marked[j] == 0:
				ans.append(j)
				flag = 1
				marked[j] = 1
				break
	if len(ans) == 2 * n:
		for i in range(len(ans)):
			print(ans[i], end=' ')
		print()
	else:
		print(-1)


import math
from collections import Counter
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	ll = []
	s = list(range(1, n + 1))
	for i in l:
		ll.append(i)
		if i + 1 not in ll and i + 1 not in l:
			ll.append(i + 1)
		else:
			j = i + 2
			while j in ll or j in l:
				j += 1
			ll.append(j)
	d = Counter(ll)
	c = 0
	for i in d:
		if i > 2 * n or d[i] > 1:
			c = 1
			break
	if c == 1:
		print(-1)
	else:
		print(*ll)


def solve():
	t = int(input())
	for i in range(t):
		n = int(input())
		b = list(map(int, input().split()))
		impossible = False
		a = [-1] * (2 * n)
		numbers = set(b)
		for (i, x) in enumerate(b):
			if impossible:
				break
			a[2 * i] = x
			bigger = x + 1
			while bigger in numbers:
				bigger += 1
			if bigger <= 2 * n:
				a[2 * i + 1] = bigger
				numbers.add(bigger)
			else:
				impossible = True
		if impossible:
			print('-1')
		else:
			print(' '.join(map(str, a)))
solve()


for _ in range(int(input())):
	n = int(input())
	b = [int(i) for i in input().strip().split()]
	taken = set(b)
	lim = 2 * n
	a = []
	for x in b:
		done = False
		pairx = None
		for y in range(x + 1, lim + 1):
			if y not in taken:
				done = True
				pairx = y
				break
		if done == False:
			break
		a += [x, pairx]
		taken.add(pairx)
	if done == False:
		print(-1)
	else:
		for x in a:
			print(x, ' ', sep='', end='')
		print()


import math
from collections import *
from functools import lru_cache
import bisect
from itertools import *
from heapq import *
inf = float('inf')
ninf = -float('inf')
ip = input
alpha = 'abcdefghijklmnopqrstuvwxyz'

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

def ipn():
	return int(input())

def ipf():
	return float(input())

def solve():
	n = ipn()
	b = ipl()
	u = [False] * (2 * n)
	r = []
	for i in b:
		u[i - 1] = True
	for i in b:
		f = False
		r.append(i)
		for x in range(i - 1, 2 * n):
			if u[x] == False:
				u[x] = True
				r.append(x + 1)
				f = True
				break
		if f == False:
			print(-1)
			return
	for i in r:
		print(i, end=' ')
	print()
for _ in range(int(input())):
	solve()


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = [1] * (2 * n + 1)
	for x in b:
		a[x] = 0
	p = []
	res = True
	for x in b:
		p.append(x)
		f = 0
		i = x + 1
		while i < 2 * n + 1:
			if a[i]:
				a[i] = 0
				p.append(i)
				f = 1
				break
			i += 1
		if not f:
			res = False
	if res:
		print(*p)
	else:
		print(-1)


t = int(input())
for i in range(t):
	n = int(input())
	L = [int(j) for j in input().split()]
	L1 = [0] * (2 * n)
	L2 = []
	for k in range(0, 2 * n, 2):
		L1[k] = L[k // 2]
	for l in range(1, 2 * n + 1, 1):
		if l not in L1:
			L2.append(l)
	for x in range(n):
		for y in range(0, 2 * n, 2):
			if L1[y + 1] == 0:
				if L2[x] > L1[y]:
					L1[y + 1] = L2[x]
					break
	if 0 in L1:
		print(-1)
	else:
		print(*L1)


TC = int(input())

def get_unused(nums, res):
	unused = set(range(1, 2 * n + 1))
	for v in res:
		unused.remove(v)
	return unused

def solve(nums):
	res = []
	n = len(nums)
	extra = 10 * n
	used = [0] * (2 * n + 1)
	for num in nums:
		res.append(extra)
		res.append(num)
		used[num] = 1
	for i in range(n):
		found = False
		for j in range(nums[i] + 1, 2 * n + 1):
			if not used[j]:
				res[2 * i] = j
				used[j] = 1
				found = True
				break
		if not found:
			return []
		if res[2 * i] > res[2 * i + 1]:
			(res[2 * i], res[2 * i + 1]) = (res[2 * i + 1], res[2 * i])
	return res
for _ in range(TC):
	n = int(input())
	(*nums,) = map(int, input().split())
	res = solve(nums)
	if res:
		print(*res)
	else:
		print(-1)


tests = int(input())
for _ in range(tests):
	size = int(input())
	full = set([i for i in range(1, 2 * size + 1)])
	restore = list(map(int, input().split()))
	check = sorted(full - set(restore))
	capture = []
	for res in restore:
		found = False
		for ch in check:
			if ch > res:
				capture.append(str(res))
				capture.append(str(ch))
				check.remove(ch)
				found = True
				break
		if not found:
			print(-1)
			break
	if len(capture) == 2 * size:
		print(' '.join(capture))


def solve(N, B):
	A = [0] * (2 * N)
	check = [False] * (2 * N)
	flag = True
	for i in range(N):
		A[i * 2] = B[i]
		check[B[i] - 1] = True
	for i in range(N):
		tmp = A[i * 2]
		for j in range(tmp, 2 * N):
			if not check[j]:
				A[i * 2 + 1] = j + 1
				check[j] = True
				break
	for i in range(N):
		if A[2 * i] > A[2 * i + 1]:
			flag = False
	if flag:
		print(' '.join(map(str, A)))
	else:
		print(-1)

def main():
	T = int(input())
	for i in range(T):
		N = int(input())
		B = list(map(int, input().split()))
		solve(N, B)
main()


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	new = []
	for i in range(n):
		temp = 0
		for j in range(1, 2 * n + 5):
			temp = arr[i] + j
			if temp not in new and temp not in arr:
				break
		new.append(temp)
	chk = 0
	ans = [0] * (2 * n)
	for i in range(0, 2 * n - 1, 2):
		ans[i] = arr[i // 2]
	for i in range(1, 2 * n, 2):
		ans[i] = new[i // 2]
	for i in ans:
		if i > 2 * n:
			chk = 1
			break
	if chk:
		print(-1)
	else:
		sss = ''
		for i in ans:
			sss += str(i) + ' '
		print(sss)


for namber in range(int(input())):
	tmp = input()
	data = list(map(int, input().split()))
	sortdat = sorted(data)
	if sortdat[0] == 1:
		maxlen = 2
		for i in range(1, len(data)):
			if sortdat[i] - sortdat[i - 1] > maxlen:
				print(-1)
				break
			elif sortdat[i] - sortdat[i - 1] == maxlen:
				maxlen = 2
			else:
				maxlen += 2 - sortdat[i] + sortdat[i - 1]
		else:
			out = [False] * (len(data) * 2)
			for j in data:
				out[j - 1] = True
			prn = ''
			for j in data:
				prn += str(j) + ' '
				tmp = j
				while out[tmp]:
					tmp += 1
				prn += str(tmp + 1) + ' '
				out[tmp] = True
			print(prn)
	else:
		print(-1)


import sys
input = lambda : sys.stdin.readline().rstrip()
from bisect import bisect_left as bl, bisect_right as br
for _ in range(int(input())):
	n = int(input())
	a = [int(i) for i in input().split()]
	b = [0] * (n * 2)
	for i in range(0, 2 * n, 2):
		b[i] = a[i // 2]
	st = set([i for i in range(1, 2 * n + 1)])
	for i in a:
		st.remove(i)
	st = list(st)
	st.sort()
	flag = 1
	for i in range(1, 2 * n, 2):
		z = br(st, b[i - 1])
		if z == len(st):
			flag = 0
			break
		b[i] = st.pop(z)
	if flag == 0:
		print(-1)
		continue
	for i in range(0, 2 * n - 1, 2):
		if b[i] > b[i + 1]:
			(b[i], b[i + 1]) = (b[i + 1], b[i])
	print(*b)


t = int(input())
for _ in range(t):
	n = int(input())
	seq = list(map(int, input().split()))
	sol = [0] * (2 * n)
	nums = {i for i in range(1, 2 * n + 1)}
	for i in range(n):
		sol[2 * i] = seq[i]
		nums.remove(seq[i])
	geht = True
	for i in range(n):
		cand = [el for el in nums if el > sol[2 * i]]
		if len(cand) == 0:
			geht = False
			break
		sol[2 * i + 1] = min(cand)
		nums.remove(min(cand))
	if geht:
		print(*sol)
	else:
		print(-1)


for _ in range(int(input())):
	length = int(input())
	a = (*map(int, input().split()),)
	rest = {*range(2 * length + 1)} - {*a}
	answer = []
	try:
		for i in a:
			temp = min(rest - {*range(i)})
			rest -= {temp}
			answer += (i, temp)
		print(*answer)
	except:
		print(-1)


for p in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [0] * (2 * n)
	for i in a:
		b[i - 1] += 1
	m = 0
	c = []
	for i in range(n):
		j = a[i]
		while j < 2 * n:
			if b[j] == 0:
				b[j] += 1
				c.append(j + 1)
				m += 1
				break
			else:
				j += 1
	if m != n:
		print(-1)
	else:
		for i in range(n):
			print(a[i], c[i], end=' ')


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	if max(b) >= n * 2 or 1 not in b:
		print(-1)
	else:
		a = [0] * (2 * n)
		ok = True
		for i in range(n):
			a[i * 2] = b[i]
		while 0 in a:
			moved = False
			for i in range(1, 1 + 2 * n):
				ind = a.index(0)
				if i not in a and i > a[ind - 1]:
					a[ind] = i
					moved = True
					break
			if not moved:
				ok = False
				break
		if not ok:
			print(-1)
		else:
			print(*a)


t = int(input())
for j in range(t):
	n = int(input())
	values = [0] * (2 * n + 2)
	b = list(map(int, input().split()))
	a = [0] * (2 * n + 2)
	for i in range(n):
		a[2 * i] = b[i]
		values[b[i]] = 1
	for i in range(n):
		check = False
		if b[i] >= 2 * n:
			break
		if values[b[i] + 1] == 0:
			values[b[i] + 1] = 1
			a[2 * i + 1] = b[i] + 1
			check = True
		else:
			for p in range(b[i] + 1, 2 * n + 1):
				if values[p] == 0:
					a[2 * i + 1] = p
					values[p] = 1
					check = True
					break
			if check == False:
				break
		if check == False:
			break
	success = True
	for i in range(2 * n):
		if a[i] > 2 * n or a[i] == 0:
			success = False
			break
	if success == False:
		print(-1)
	else:
		for i in range(2 * n):
			print(a[i], end=' ')
		print()


kl = int(input())
for l in range(kl):
	n = int(input())
	t = n * 2
	at = list(range(t + 1))
	nl = [1] * t
	b = []
	rz = []
	pr = 0
	for i in input().split():
		i = int(i)
		nl[i - 1] = 0
		b = b + [i]
	for i in range(n):
		if pr:
			break
		pr = 1
		for j in range(b[i], t + 1):
			if at[j] * nl[j - 1] != 0:
				nl[j - 1] = 0
				rz = rz + [b[i]] + [at[j]]
				pr = 0
				break
	if pr:
		print(-1)
	else:
		for i in range(t):
			print(rz[i], '', end='')


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	s = set(b)
	ans = []
	possible = True
	for x in b:
		y = x + 1
		while y <= 2 * n:
			if y not in s:
				break
			y = y + 1
		if y > 2 * n:
			possible = False
			break
		s.add(y)
		ans.append(x)
		ans.append(y)
	if possible:
		print(' '.join(map(str, ans)))
	else:
		print('-1')


T = int(input().strip())
debug = False
for t in range(T):
	N = int(input().strip())
	A = list(map(int, input().split()))
	totalSum = 2 * N * (2 * N + 1) / 2
	total = 0
	d = {}
	for a in A:
		d[a] = 1
	B = []
	for a in A:
		B.append(a)
		total += a
		x = a
		while True:
			x = x + 1
			if x not in d:
				d[x] = 1
				B.append(x)
				total += x
				break
	if total == totalSum:
		print(*B)
	else:
		print(-1)


t = int(input())
for _ in range(t):
	n = int(input())
	b = [int(x) for x in input().split()]
	d = sorted(b)
	c = []
	j = 0
	for i in range(1, 2 * n + 1):
		if j < len(d) and i == d[j]:
			j += 1
		else:
			c.append(i)
	j = 0
	out = []
	for val in b:
		out.append(val)
		while j < len(c):
			if c[j] > val:
				out.append(c[j])
				c[j] = -1
				j = 0
				break
			else:
				j += 1
		else:
			print(-1)
			break
	else:
		print(' '.join(map(str, out)))


import sys, os, io
from sys import stdin
import math
from collections import defaultdict
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
alphabets = list('abcdefghijklmnopqrstuvwxyz')
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(int(i))
			n = n / i
	if n > 2:
		l.append(n)
	return list(set(l))

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def sieveForSmallestPrimeFactor():
	MAXN = 100001
	spf = [0 for i in range(MAXN)]
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, math.ceil(math.sqrt(MAXN))):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
	return spf

def getPrimeFactorizationLOGN(x):
	spf = sieveForSmallestPrimeFactor()
	ret = list()
	while x != 1:
		ret.append(spf[x])
		x = x // spf[x]
	return ret

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def si():
	return input()

def divideCeil(n, x):
	if n % x == 0:
		return n // x
	return n // x + 1

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))

def solve():
	n = ii()
	b = li()
	d = defaultdict(lambda : 0)
	for i in b:
		d[i] = 1
	noth = []
	for i in range(1, 2 * n + 1):
		if d[i] == 0:
			noth.append(i)
	ans = []
	s = SortedList(noth)
	for i in range(n):
		ptr = s.bisect_left(b[i])
		if ptr == len(s) or s[ptr] < b[i]:
			print(-1)
			return
		ans.append(b[i])
		ans.append(s[ptr])
		s.remove(s[ptr])
	print(*ans)
t = 1
t = ii()
for _ in range(t):
	solve()


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

def li():
	return list(mi())

def ii():
	return int(input())

def si():
	return input()
t = ii()
while t:
	t -= 1
	n = ii()
	a = li()
	b = a[:]
	b.sort()
	a1 = []
	l = 0
	for i in range(1, 2 * n + 1):
		if l < len(b) and i == b[l]:
			l += 1
		else:
			a1.append(i)
	f = 0
	m = {}
	for i in range(n):
		if b[i] > a1[i]:
			f = 1
		m[b[i]] = a1[i]
	if f:
		print('-1')
	else:
		for i in a:
			print(i, end=' ')
			for j in range(n):
				if a1[j] > i:
					print(a1[j], end=' ')
					a1[j] = 0
					break
		print()


import heapq

def restorePermutation(n, A):
	ans = []
	unUsed = set(list(range(1, 2 * n + 1)))
	for val in A:
		if not 1 <= val <= 2 * n:
			return -1
		ans.append(val)
		ans.append(-1)
		unUsed.remove(val)
	minHeapq = [val for val in unUsed]
	heapq.heapify(minHeapq)
	for i in range(1, 2 * n, 2):
		temp = []
		while minHeapq and minHeapq[0] < ans[i - 1]:
			temp.append(heapq.heappop(minHeapq))
		if not minHeapq or (minHeapq and minHeapq[0] < ans[i - 1]):
			return -1
		ans[i] = heapq.heappop(minHeapq)
		while temp:
			heapq.heappush(minHeapq, temp.pop())
	return ans
testCases = int(input())
while testCases:
	n = int(input())
	A = [int(val) for val in input().split()]
	ans = restorePermutation(n, A)
	if ans == -1:
		print()
		print(ans)
	else:
		for val in ans:
			print(val, end=' ')
	testCases -= 1


import sys
import collections
input = sys.stdin.readline

def main():
	t = int(input())
	for _ in range(t):
		N = int(input())
		B = [int(x) for x in input().split()]
		c = collections.Counter()
		ans = []
		for b in B:
			if c[b] > 0:
				print(-1)
				break
			ans.append(b)
			c[b] += 1
			i = 1
			while c[b + i] != 0 or b + i in B:
				i += 1
			ans.append(b + i)
			c[b + i] += 1
		else:
			for i in range(1, 2 * N + 1):
				if c[i] == 0:
					print(-1)
					break
			else:
				print(*ans)
main()


def min_largest(arr, x):
	start = 0
	end = len(arr) - 1
	while start <= end:
		mid = start + (end - start) // 2
		if arr[mid] < x:
			start = mid + 1
		else:
			end = mid - 1
	result = start if start < len(arr) else -1
	return result

def permutation(arr, n):
	present = set(arr)
	missing = [i for i in range(1, 2 * n + 1) if i not in present]
	result = []
	for number in arr:
		result.append(number)
		temp = min_largest(missing, number)
		if temp == -1:
			return [-1]
		result.append(missing.pop(temp))
	return result
T = int(input())
for t in range(T):
	n = int(input())
	arr = list(map(int, input().split()))
	result = permutation(arr, n)
	for item in result:
		print(item, end=' ')
	print()


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	dic = {}
	ans = []
	boo = False
	for i in a:
		dic[i] = 0
	for i in a:
		ans.append(i)
		temp = i + 1
		while True:
			if temp > 2 * n:
				boo = True
				break
			if temp not in dic.keys():
				dic[temp] = 0
				ans.append(temp)
				break
			temp += 1
		if boo:
			break
	if boo:
		print(-1)
	else:
		print(*ans)


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	a = [*range(1, 2 * n + 1)]
	b = [i for i in a + l if i not in a or i not in l]
	b.sort()
	ans = []
	used = []
	f = 0
	for i in l:
		for j in b:
			if j > i and j not in used:
				used.append(j)
				ans.append(i)
				ans.append(j)
				break
	if len(ans) != 2 * n:
		print(-1)
	else:
		print(*ans)


import copy
for i in range(int(input())):
	n = int(input())
	l = [int(j) for j in input().split()][:n]
	l1 = list(set(list(range(1, 2 * n + 1))).difference(set(l)))
	t = copy.deepcopy(l)
	l1.sort()
	m = -1
	for k in range(n):
		h = -1
		for j in range(n):
			if l1[j] > t[k]:
				if l1[j] not in l:
					a = l.index(t[k])
					l.insert(a + 1, l1[j])
					h = 1
					break
		if h == -1:
			print('-1')
			m = 1
			break
	if m == -1:
		for k in l:
			print(k, end=' ')
		print()


nn = int(input())
for tt in range(nn):
	total = []
	num = int(input())
	arr = []
	arr1 = str(input())
	arr1 = arr1.split()
	dicts = {}
	last = 2 * num
	for i in arr1:
		kt = int(i)
		arr.append(int(i))
		dicts[kt] = 1
	ans = []
	flag = 0
	for i in arr:
		ans.append(i)
		while True:
			i += 1
			if i > last:
				flag = 1
				break
			if i not in dicts:
				dicts[i] = 1
				ans.append(i)
				break
		if flag == 1:
			break
	if flag == 1:
		print(-1)
	else:
		strs = ''
		for i in ans:
			strs += str(i)
			strs += ' '
		print(strs)


for _ in range(int(input())):
	n = int(input())
	b = [int(i) for i in input().split()]
	missed = []
	sorted_b = sorted(b)
	for (ind, num) in enumerate(sorted_b):
		if ind != 0:
			missed.extend(list(range(sorted_b[ind - 1] + 1, num)))
		else:
			missed.extend(list(range(1, num)))
	if sorted_b[-1] != 2 * n:
		missed.extend(range(sorted_b[-1] + 1, 2 * n + 1))
	ans = []
	flag = 0
	for num in b:
		m = float('inf')
		for candidate in missed:
			if num < candidate < m:
				m = candidate
		if m != float('inf'):
			del missed[missed.index(m)]
		else:
			flag = 1
			break
		if min(m, num) == num:
			ans.extend([num, m])
	if flag == 0:
		print(*ans)
	else:
		print(-1)


import sys
t = int(sys.stdin.readline())
for i in range(t):
	n = int(sys.stdin.readline())
	b = [int(j) for j in sys.stdin.readline().split()]
	arr = []
	tot = 2 * n
	mark = [0] * tot
	for g in range(n):
		mark[b[g] - 1] = 1
	ans = True
	for h in range(n):
		done = 0
		for k in range(2 * n):
			if mark[k] == 0 and k + 1 > b[h]:
				mark[k] = 1
				tmp = [b[h], k + 1]
				tmp.sort()
				arr.append(tmp)
				done = 1
				break
		if done == 0:
			ans = False
			break
	if ans == True:
		for w in range(n):
			print(arr[w][0], end=' ')
			print(arr[w][1], end=' ')
		print()
	else:
		print(-1)


import os
import sys
from io import BytesIO, IOBase
from bisect import bisect

def solution(arr, n):
	all_set = [i for i in range(1, 2 * n + 1)]
	for (i, x) in enumerate(arr):
		all_set.remove(arr[i])
	res = []
	for i in range(n):
		idx = bisect(all_set, arr[i])
		if idx == len(all_set):
			print(-1)
			return
		res.append(arr[i])
		res.append(all_set[idx])
		all_set.pop(idx)
	for x in res:
		print(x, end=' ')
	print()

def main():
	t = int(input())
	for _ in range(t):
		n = int(input())
		arr = [int(x) for x in input().split()]
		solution(arr, n)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')
main()


for ttt in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	if 2 * n in arr or 1 not in arr:
		print(-1)
		continue
	res = []
	for i in range(n):
		res.append(arr[i])
		for j in range(arr[i] + 1, 2 * n + 1):
			if j not in arr and j not in res:
				res.append(j)
				break
	if len(res) == 2 * n:
		print(*res)
	else:
		print(-1)


import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]

def solve(n, bb):
	res = []
	used = [False] * (2 * n + 1)
	for b in bb:
		used[b] = True
	for b in bb:
		for c in range(b + 1, 2 * n + 1):
			if not used[c]:
				res += [b, c]
				used[c] = True
				break
		else:
			return [-1]
	return res

def main():
	t = II()
	for _ in range(t):
		n = II()
		bb = LI()
		ans = solve(n, bb)
		print(*ans)
main()


for _ in range(int(input())):
	n = int(input())
	B = list(map(int, input().split()))
	A = []
	for i in range(n):
		A.append(B[i])
		for j in range(B[i] + 1, 1000):
			if j not in A and j not in B:
				A.append(j)
				break
	C = []
	for i in range(0, 2 * n):
		C.append(A[i])
	C.sort()
	ans = -1
	for j in range(0, 2 * n):
		if C[i] != i + 1:
			ans = 0
			break
	if ans == 0:
		print('-1')
	else:
		print(*A)


te = int(input())
while te > 0:
	te -= 1
	n = int(input())
	B = list(map(int, input().split()))
	D = {}
	for i in B:
		D[i] = 1
	ans = []
	i = 0
	while i < n:
		ans.append(B[i])
		k = B[i]
		while k < 2 * n:
			k += 1
			if D.get(k) is None:
				D[k] = 1
				ans.append(k)
				break
		i += 1
	if len(ans) == 2 * n:
		for i in ans:
			print(i, end=' ')
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	used = set(a)
	ans = []
	for i in range(n):
		ans.append(a[i])
		for j in range(a[i] + 1, n << 1 | 1):
			if j not in used:
				ans.append(j)
				used.add(j)
				break
		else:
			print(-1)
			break
	else:
		print(*ans)


for i in range(int(input())):
	n = int(input())
	nums = [int(i) for i in input().split()]
	check = set(nums)
	s = max(nums)
	l = [int(i) + 1 if int(i) + 1 not in check else 0 for i in range(2 * n)]
	l = sorted(list(set(l)))
	l.remove(0)
	o = ''
	b = 0
	for i in nums:
		s = 0
		while s < len(l) and l[s] < i:
			s += 1
		if s == len(l):
			b = 1
			break
		else:
			o += str(i) + ' ' + str(l[s]) + ' '
			l.remove(l[s])
	if b:
		print(-1)
	else:
		print(o[:-1])


T = int(input())
for _ in range(T):
	a = int(input())
	A = list(map(int, input().split()))
	DP = [0 for i in range(2 * a + 1)]
	flag = 0
	for i in A:
		if i > 2 * a:
			flag = 1
		else:
			DP[i] = 1
	if flag == 1:
		print(-1)
		continue
	else:
		mv = a
		B = []
		for i in range(a):
			flag = 0
			b = A[i]
			B.append(b)
			for j in range(b, 2 * a + 1):
				if DP[j] == 0:
					flag = 1
					B.append(j)
					DP[j] = 1
					break
			if flag == 0:
				B = [-1]
				break
		for i in B[:len(B) - 1]:
			print(i, end=' ')
		print(B[len(B) - 1])


t = int(input())
while t:
	t -= 1
	n = int(input())
	vis = [False] * (2 * n)
	ans = [-1] * (2 * n)
	b = list(map(int, input().split()))

	def check():
		global vis
		for i in b:
			if vis[i - 1] is False:
				vis[i - 1] = True
			else:
				return False
		return True
	if check() is False:
		print(-1)
		continue

	def solve():
		global ans, vis
		for i in range(0, 2 * n, 2):
			j = i // 2
			ans[i] = b[j]
			for k in range(b[j] + 1, 2 * n + 1):
				if vis[k - 1] is False:
					vis[k - 1] = True
					ans[i + 1] = k
					break
			if ans[i + 1] == -1:
				return False
		return True
	if solve() is False:
		print(-1)
		continue
	else:
		print(*ans)


cases = int(input())
for t in range(cases):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0] * (2 * n)
	d = {i: True for i in range(1, 2 * n + 1)}
	for i in range(n):
		p = i + 1
		pos = 2 * p - 1
		a[pos - 1] = b[i]
		d[b[i]] = False
	f = 0
	for i in range(n):
		p = i + 1
		pos = 2 * p
		v = b[i] + 1
		while v in d and (not d[v]):
			v += 1
		if v > 2 * n:
			print(-1)
			f = 1
			break
		else:
			d[v] = False
			a[pos - 1] = v
	if f == 0:
		print(*a)


for _ in range(int(input())):
	n = int(input())
	L = [int(x) for x in input().strip().split(' ')]
	exist = set(L)
	todo = set()
	for i in range(1, 2 * n + 1):
		if i not in exist:
			todo.add(i)
	res = []
	flag = True
	for x in L:
		for e in range(x + 1, 2 * n + 1):
			if e in todo:
				res.append(x)
				res.append(e)
				todo.remove(e)
				break
		else:
			flag = False
			break
	if not flag:
		print(-1)
	else:
		for x in res:
			print(x, end=' ')
		print()


t = int(input())
for i in range(t):
	n = int(input())
	l = [0] * 2 * n + [0, 0]
	b = list(map(int, input().split()))
	if 1 not in b:
		print(-1)
	else:
		t = 1
		b.insert(0, 0)
		for i in range(1, n + 1):
			(l[2 * i - 1], w) = (b[i], b[i])
			while w in b or w in l:
				w += 1
			if w > 2 * n:
				t = 0
				break
			l[2 * i] = w
		l.pop(0)
		l.pop(-1)
		if t:
			print(*l)
		else:
			print(-1)


t = int(input())
M = []

def fonction(n, L):
	if max(L) >= 2 * n:
		return -1
	elif len(set(L)) != len(L):
		return -1
	else:
		res = list()
		D = list()
		for k in L:
			j = k
			ra = [D[i][1] for i in range(len(D))]
			while (j in ra or j in L) and j <= 2 * n:
				j += 1
			D.append((k, j))
			res.append(k)
			res.append(j)
		if sorted(res) == [k for k in range(1, 2 * n + 1)]:
			return res
		else:
			return -1
for i in range(t):
	n = int(input())
	L = [int(x) for x in input().split()]
	M.append(fonction(n, L))
for k in M:
	if type(k) == list:
		dh = ' '.join([str(i) for i in k])
		for x in dh.split()[:-1]:
			print(int(x), end=' ')
		print(int(dh.split()[-1]))
	else:
		print(k)


import os
import heapq
import sys, threading
import math as mt
import operator
from copy import copy
from collections import defaultdict, deque
from io import BytesIO, IOBase
sys.setrecursionlimit(2 * 10 ** 5)

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def inpt():
	return [int(k) for k in input().split()]

def main():
	for _ in range(int(input())):
		n = int(input())
		ar = inpt()
		st = set(ar)
		temp = []
		for i in range(1, 2 * n + 1):
			if i not in st:
				temp.append(i)
		temp.sort()
		ans = [0] * (2 * n)
		j = 0
		ok = True
		for i in range(0, 2 * n - 1, 2):
			ans[i] = ar[i // 2]
		st = set()
		for i in range(1, 2 * n, 2):
			mn = 10 ** 9
			for j in temp:
				if j not in st and j > ans[i - 1]:
					mn = min(mn, j)
			if mn == 10 ** 9:
				ok = False
				break
			ans[i] = mn
			st.add(mn)
		if not ok:
			print(-1)
		else:
			print(*ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	m = [1 for j in range(2 * n)]
	for k in b:
		m[k - 1] = 0
	a = []
	mega_bul = True
	for el in b:
		a.append(el)
		ind = 0
		bul = False
		while ind < 2 * n:
			if ind + 1 > el and m[ind] == 1:
				m[ind] = 0
				a.append(ind + 1)
				bul = True
				break
			ind += 1
		if not bul:
			mega_bul = False
			break
	if mega_bul:
		print(' '.join(map(str, a)))
	else:
		print(-1)


import sys
t = int(input())
while t:
	t -= 1
	n = int(input())
	b = list(map(int, input().split()))
	l = [i for i in range(1, 2 * n + 1) if i not in b]
	ans = []
	k = 0
	for i in range(n):
		c = 0
		ans.append(b[i])
		for j in range(n):
			if l[j] > b[i] and l[j] not in ans:
				c = 1
				break
		if c == 1:
			ans.append(l[j])
		else:
			k = 1
			print(-1)
			break
	if k == 1:
		continue
	else:
		print(*ans)


import sys
import copy
input = sys.stdin.buffer.readline
t = int(input())
while t:
	t -= 1
	n = int(input())
	arr = list(map(int, input().split()))
	arr1 = copy.deepcopy(arr)
	arr1.sort()
	if arr1[0] == 1:
		if max(arr) + 1 <= 2 * n:
			ans = []
			for i in range(n):
				ans.append(arr[i])
				for j in range(arr[i] + 1, 2 * n + 1):
					if j not in arr1:
						ans.append(j)
						arr1.append(j)
						break
			if len(set(ans)) != 2 * n:
				print('-1')
			else:
				for x in ans:
					print(x, end=' ')
				print()
		else:
			print('-1')
	else:
		print('-1')


import sys
import bisect

def main():
	n = int(sys.stdin.readline())
	q = [int(i) for i in sys.stdin.readline().split()]
	w = []
	for i in range(1, 2 * n + 1):
		if i not in q:
			w.append(i)
	w.sort()
	res = [0 for i in range(2 * n)]
	for i in range(n):
		res[i * 2] = q[i]
	for i in range(n - 1):
		e = bisect.bisect(w, q[i])
		if e != n - i:
			r = w[e]
			del w[e]
			res[i * 2 + 1] = r
		else:
			print(-1)
			return 0
	if w[-1] < q[-1]:
		print(-1)
		return 0
	else:
		res[-1] = w[-1]
		print(*res)
for test in range(int(sys.stdin.readline())):
	main()


for T in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	Ans = []
	Exist = [False] * (2 * n + 100)
	Bad = False
	for i in b:
		Exist[i] = True
	for i in range(n):
		Ans.append(b[i])
		Number = b[i] + 1
		while Exist[Number] == True and Number < 2 * n:
			Number += 1
		if Number <= 2 * n and Exist[Number] == False:
			Ans.append(Number)
			Exist[Number] = True
		else:
			Bad = True
			break
	if Bad:
		print(-1)
	else:
		print(*Ans)


from collections import *
for i in range(int(input())):
	(n, a, ans) = (int(input()), list(map(int, input().split())), [])
	mem = Counter(a)
	for j in range(n):
		ans.append(a[j])
		for k in range(a[j] + 1, 2 * n + 1):
			if not mem[k]:
				ans.append(k)
				mem[k] = 1
				break
		if ans[-1] == a[j]:
			ans = [-1]
			break
	print(*ans)


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	r = []
	for i in range(1, 2 * n + 1):
		if i in l:
			pass
		else:
			r.append(i)
	i = 0
	k = []
	while len(r) > 0 or i < n:
		for j in range(len(r)):
			if l[i] < r[j]:
				k.append(r[j])
				break
		r.remove(r[j])
		i = i + 1
	if len(k) == n:
		for i in range(n):
			print(l[i], k[i], end=' ')
		print()
	else:
		print('-1')


import sys
input = lambda : sys.stdin.readline().strip()
for i in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	q = [i + 1 for i in range(2 * n)]
	used = set(b)
	j = 0
	a = [0] * 2 * n
	f = True
	for i in range(n):
		a[2 * i] = b[i]
	for i in range(n):
		for j in q[b[i] - 1:]:
			if j not in used:
				used.add(j)
				a[2 * i + 1] = j
				break
		if a[2 * i + 1] == 0:
			f = False
			break
	if not f:
		print(-1)
		continue
	else:
		print(' '.join(map(str, a)))


Q = int(input())
for _ in range(Q):
	n = int(input())
	b = list(map(int, input().split()))
	s = {*range(2 * n + 1)} - {*b}
	a = []
	try:
		for i in b:
			minn = min(s - {*range(i)})
			s -= {minn}
			a += (i, minn)
	except:
		a = (-1,)
	print(*a)


def bubbleSort(arr):
	n = len(arr)
	for i in range(n):
		for j in range(0, n - i - 1):
			if arr[j] < arr[j + 1]:
				(arr[j], arr[j + 1]) = (arr[j + 1], arr[j])
number_of_testcase = int(input())
for i in range(number_of_testcase):
	n = int(input())
	numbers_list = list(map(int, input().split(' ')))
	initial_list = numbers_list.copy()
	available_numbers = [x for x in list(range(1, 2 * n + 1)) if x not in initial_list]
	flag2 = 1
	final_dict = {}
	for i in initial_list:
		flag = 0
		for j in available_numbers:
			if i < j:
				flag = 1
				final_dict[i] = j
				available_numbers.remove(j)
				break
		if flag == 0:
			print('-1')
			flag2 = 0
			break
	if flag2 == 1:
		for j in initial_list:
			print(str(j) + ' ' + str(final_dict[j]), end=' ')
		print('')


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [i for i in range(1, 2 * n + 1) if i not in a]
	sol = [0] * (2 * n)
	for i in range(len(a)):
		tmp = [j for j in b if j > a[i]]
		if len(tmp) == 0:
			sol = -1
			break
		else:
			sol[2 * i] = a[i]
			sol[2 * i + 1] = tmp[0]
			b.remove(tmp[0])
	if sol == -1:
		print(sol)
	else:
		print(' '.join([str(i) for i in sol]))


import heapq as hq
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	sb = sorted([(b[i] - 1, i) for i in range(n)]) + [(2 * n + 1, -1)]
	a = [0] * (2 * n)
	pos = []
	ind = 0
	for i in range(2 * n):
		if i < sb[ind][0]:
			if len(pos) == 0:
				a = ['-1']
				break
			p = hq.heappop(pos)
			a[p] = str(i + 1)
		else:
			p = 2 * sb[ind][1]
			a[p] = str(i + 1)
			hq.heappush(pos, p + 1)
			ind += 1
	print(' '.join(a))


test = int(input())
for i in range(test):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0 for i in range(n + n)]
	l = [0 for i in range(n + n + 1)]
	for i in range(n):
		a[2 * i] = b[i]
		l[b[i]] = 1
	ans = 1
	for i in range(n):
		bool = 0
		for j in range(b[i] + 1, n + n + 1):
			if l[j] == 1:
				continue
			a[2 * i + 1] = j
			l[j] = 1
			bool = 1
			break
		if bool == 0:
			ans = 0
			break
	if ans == 0:
		print(-1)
	else:
		for i in range(n + n):
			print(a[i], end=' ')
		print()


t = int(input())
for _ in range(t):
	n = int(input())
	B = [int(i) for i in input().split()]
	BB = set(B)
	Chk = True
	Ans = []
	Used = [True] * (2 * n)
	for i in range(2 * n):
		if i + 1 in BB:
			Used[i] = False
	for b in B:
		Ans.append(b)
		for i in range(b, 2 * n):
			if Used[i]:
				Ans.append(i + 1)
				Used[i] = False
				break
		else:
			Chk = False
	if Chk:
		print(*Ans)
	else:
		print(-1)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import bisect
testcases = int(input())
for j in range(testcases):
	n = int(input())
	vals = list(map(int, input().split()))
	setty = set(vals)
	unused = []
	for s in range(1, 2 * n + 1):
		if not s in setty:
			unused.append(s)
	outy = []
	broke = False
	for s in range(n):
		b1 = vals[s]
		b2 = unused[min(bisect.bisect_left(unused, b1), len(unused) - 1)]
		if b1 < b2:
			unused.pop(min(bisect.bisect_left(unused, b1), len(unused) - 1))
			outy.append(b1)
			outy.append(b2)
		else:
			broke = True
	if broke == True:
		print(-1)
	else:
		print(*outy)


t = int(input())
for _ in range(t):
	n = int(input())
	B = list(map(int, input().split()))
	cands = [True] * (2 * n)
	for b in B:
		cands[b - 1] = False
	ret = []
	for b in B:
		ret.append(b)
		for i in range(2 * n):
			if b < i + 1 and cands[i]:
				ret.append(i + 1)
				cands[i] = False
				break
		else:
			ret = [-1]
			break
	print(*ret)


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	arr2 = []
	for i in arr:
		arr2.append(i)
		t = i + 1
		while t in arr or t in arr2:
			t += 1
		arr2.append(t)
	if max(arr2) == 2 * n:
		print(*arr2)
	else:
		print('-1')


t = int(input())
while t:
	n = int(input())
	b = input().split()
	visited = [0 for i in range(2 * n + 1)]
	a = []
	for i in range(n):
		b[i] = int(b[i])
		visited[b[i]] = 1
	for i in range(n):
		a.append(b[i])
		flag = False
		for j in range(b[i] + 1, 2 * n + 1):
			if visited[j] == 0:
				flag = True
				visited[j] = 1
				a.append(j)
				break
		if flag == False:
			break
	if flag == False:
		print(-1)
	else:
		print(*a)
	t -= 1


for t in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	ll = []
	ans = 0
	for i in range(n):
		k = l[i] + 1
		while k in l or k in ll:
			k += 1
		if k > 2 * n:
			ans = -1
			break
		ll.append(k)
	if ans == 0:
		for i in range(n):
			print(l[i], ll[i], end=' ')
		print()
	else:
		print(-1)


class GFG:

	def __init__(self, graph, seq):
		self.graph = graph
		self.ppl = len(graph)
		self.jobs = len(graph[0])
		self.seq = seq

	def bpm(self, u, matchR, seen):
		for v in range(self.jobs - 1, -1, -1):
			if self.graph[u][v] and seen[v] == False:
				seen[v] = True
				if matchR[v] == -1 or self.bpm(matchR[v], matchR, seen):
					matchR[v] = u
					return True
		return False

	def maxBPM(self):
		matchR = [-1] * self.jobs
		result = 0
		for i in self.seq:
			i -= 1
			seen = [False] * self.jobs
			if self.bpm(i, matchR, seen):
				result += 1
		self.matchR = matchR
		return result
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	g = [[0 for _ in range(2 * n)] for _ in range(2 * n)]
	for i in b:
		for j in range(i, 2 * n):
			if j + 1 not in b:
				g[i - 1][j] = 1
	m = GFG(g, b)
	if m.maxBPM() != n:
		print(-1)
	else:
		for i in b:
			print(i, m.matchR.index(i - 1) + 1, end=' ')
		print()


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	d = {}
	for i in range(1, 2 * n + 1):
		d[i] = 1
	for i in b:
		d[i] = 0
	a = []
	for i in b:
		a.append(i)
		z = i
		for j in range(z + 1, 2 * n + 1):
			if d[j]:
				z = j
				d[j] = 0
				break
		if z != i:
			a.append(z)
		else:
			break
	if len(a) == 2 * n:
		print(' '.join(map(str, a)))
	else:
		print(-1)


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
from heapq import *
from math import gcd, factorial, floor, ceil
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

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

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

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for pp in range(t):
		solve(pp)

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def google(p):
	print('Case #' + str(p) + ': ', end='')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
inf = pow(10, 20)
mod = 10 ** 9 + 7

def solve(case):
	n = int(inp())
	a = lis()
	if 1 not in a:
		print(-1)
		return
	if len(set(a)) != n:
		print(-1)
		return
	vis = [0] * (2 * n + 1)
	ans = [-1] * (2 * n)
	for i in range(n):
		vis[a[i]] = 1
		ans[2 * i] = a[i]
	for i in range(1, 2 * n, 2):
		for j in range(ans[i - 1] + 1, 2 * n + 1):
			if vis[j] == 0:
				ans[i] = j
				vis[j] = 1
				break
	for i in range(1, 2 * n + 1):
		if vis[i] == 0:
			print(-1)
			return
	print(' '.join((str(ans[i]) for i in range(2 * n))))
testcase(int(inp()))


t = int(input())
for ii in range(t):
	n = int(input())
	flag = True
	a = [int(i) for i in input().split()]
	t = n * 2
	b = [0] * (t + 1)
	c = []
	for i in a:
		if i == t:
			flag = False
			break
		b[i] = 1
	if flag == False:
		print(-1)
	else:
		for i in a:
			c.append(i)
			j = i + 1
			while b[j] == 1:
				if j == t and b[j] == 1:
					flag = False
					break
				j += 1
			if flag == False:
				print(-1)
				break
			c.append(j)
			b[j] = 1
		for i in c:
			if flag == True:
				print(i, end=' ')
		if flag == True:
			print()


import sys
from bisect import bisect_left
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__

def find_ge(a, x):
	i = bisect_left(a, x)
	if i != len(a):
		return a[i]
	return False

def gift():
	for _ in range(cou):
		n = int(input())
		lst = [int(x) for x in input().split()]
		newlst = lst[:]
		newlst.sort()
		less = 0
		big = 0
		onein = False
		bignotin = True
		error = False
		full = list(range(1, n * 2 + 1))
		for ele in newlst:
			if ele <= n:
				less += 1
			else:
				big += 1
			if ele == 1:
				onein = True
			if ele == n * 2:
				bignotin = False
			full.remove(ele)
		if onein and bignotin and (less >= big):
			res = []
			for ele in lst:
				found = find_ge(full, ele)
				if not found:
					error = True
					break
				res.append(ele)
				res.append(found)
				full.remove(found)
			if error:
				yield (-1)
			else:
				yield ' '.join((str(x) for x in res))
		else:
			yield (-1)
cou = int(input())
ans = gift()
print(*ans, sep='\n')


from os import path
from sys import stdin, stdout
from bisect import bisect_left, bisect_right
maxn = 200005
dd = [0 for i in range(maxn)]
a = [0 for i in range(maxn)]
if path.exists('inp.txt'):
	stdin = open('inp.txt', 'r')
q = int(stdin.readline())
for _ in range(q):
	s = []
	check = 0
	n = int(stdin.readline())
	res = [0 for i in range(2 * n + 1)]
	for i in range(1, 2 * n + 1):
		dd[i] = 0
	a[1:] = list(map(int, stdin.readline().split()))
	for i in a:
		dd[i] += 1
	for i in range(1, 2 * n + 1):
		if not dd[i]:
			s.append(i)
	for i in range(1, n + 1):
		if bisect_left(s, a[i]) != len(s):
			res[2 * i - 1] = a[i]
			res[2 * i] = s[bisect_left(s, a[i])]
			s.pop(bisect_left(s, a[i]))
		else:
			check = 1
			break
	if not check:
		print(*res[1:])
	else:
		print(-1)


from sys import stdin
from collections import defaultdict
from bisect import bisect_right
input = stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	dict = defaultdict(int)
	arr = []
	for i in range(n):
		arr.append([a[i], i])
		dict[a[i]] = 1
	arr.sort()
	tmp = []
	for i in range(1, 2 * n + 1):
		if dict[i] == 0:
			tmp.append(i)
	fl = 0
	farr = {}
	for i in range(len(tmp)):
		if arr[i][0] > tmp[i]:
			fl = 1
			break
	if fl == 1:
		print(-1)
		continue
	for x in a:
		val = tmp[bisect_right(tmp, x)]
		tmp.remove(val)
		print(x, val, end=' ')
	print()


t = int(input())
for i in range(t):
	n = int(input())
	b = [0] * (2 * n)
	a = list(map(int, input().split()))
	if 1 not in a:
		print(-1)
	else:
		f = 0
		s = set()
		for i in range(n):
			if a[i] >= 2 * n:
				f = 1
				break
			else:
				b[2 * i] = a[i]
				s.add(a[i])
		fl = []
		for i in range(1, 2 * n + 1):
			if i not in s:
				fl.append(i)
		fl.sort()
		for i in range(n):
			ind = 0
			while fl[ind] < b[2 * i]:
				ind += 1
				if ind == n:
					break
			if ind == n:
				break
			b[2 * i + 1] = fl[ind]
			fl[ind] = 0
		if f == 1 or 0 in b:
			print(-1)
		else:
			print(*b, sep=' ')


t = int(input())
for _ in range(0, t):
	n = int(input())
	bb = [int(i) for i in input().split()]
	le = [int(i) for i in range(1, 2 * n + 1) if i not in bb]
	aa = [0] * (2 * n)
	ii = 0
	for i in range(0, n):
		aa[ii] = bb[i]
		ii += 2
	ii = 1
	k = True
	for i in range(0, n):
		k = [ss for ss in le if ss > bb[i]]
		if len(k) == 0:
			k = False
			break
		else:
			kk = min(k)
			aa[ii] = kk
			le.remove(kk)
			ii += 2
	if k:
		print(*aa)
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	s = [*map(int, input().split())]
	ans = []
	for i in s:
		ans.append(i)
		t = i + 1
		while t in s or t in ans:
			t += 1
		ans.append(t)
	if sorted(ans) == [i for i in range(1, 2 * n + 1)]:
		print(*ans)
	else:
		print(-1)


for i in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	a = []
	i = 0
	t = 0
	while len(a) != 2 * n:
		if t == 0:
			r = arr[i]
			a.append(arr[i])
		if r + 1 not in arr and r + 1 not in a:
			a.append(r + 1)
			i += 1
			t = 0
		else:
			r += 1
			t = 1
	b = []
	for i in a:
		b.append(i)
	c = []
	b.sort()
	for i in range(2 * n):
		c.append(i + 1)
	if b != c:
		print(-1)
	else:
		print(*a)


T = int(input())
while T != 0:
	T -= 1
	n = int(input())
	arr = [int(x) for x in input().split()]
	st = set()
	for i in range(1, 2 * n + 1):
		st.add(i)
	for i in arr:
		st.discard(i)
	ans = []
	for i in arr:
		ans.append(i)
		for j in sorted(st):
			if j > i:
				ans.append(j)
				st.discard(j)
				break
	if len(ans) == 2 * n:
		for i in ans:
			print(i, end=' ')
		print()
	else:
		print(-1)


from sys import exit
from bisect import bisect

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

def ii():
	return int(input())

def liis():
	return list(map(int, input().split()))
t = ii()
for _ in range(t):
	n = ii()
	b = liis()
	todos = []
	duplas = []
	for i in range(1, 2 * n + 1):
		if i not in b:
			todos.append(i)
	flag = False
	for i in b:
		a = bisect(todos, i)
		if a >= len(todos):
			flag = True
			break
		duplas.append([i, todos[a]])
		todos[a] = -1
		todos = sorted(todos)
	if flag:
		print(-1)
	else:
		for dupla in duplas:
			print(' '.join(map(str, dupla)), end=' ')
		print()


t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	l = [i + 1 for i in range(2 * n)]
	q = sorted(b)
	ans = True
	ansList = []
	count = 0
	if q[0] != 1:
		print(-1)
		continue
	for i in range(1, 2 * n - 1):
		if i not in q and i + 1 not in q:
			if count == 0:
				ans = False
				break
			else:
				count -= 1
		if i in q and i + 1 in q:
			count += 1
	if ans == False:
		print(-1)
	else:
		for i in b:
			ansList.append(i)
			i += 1
			while i < 2 * n + 1:
				if i not in ansList and i not in q:
					ansList.append(i)
					break
				i += 1
		print(*ansList)


for _ in range(int(input())):
	N = int(input())
	L = list(map(int, input().split()))
	Hash = [0] * (2 * N + 1)
	for i in range(N):
		Hash[L[i]] += 1
	Nahi = []
	for i in range(N):
		FLAG = 0
		for j in range(L[i] + 1, 2 * N + 1):
			if Hash[j] == 0:
				FLAG = 1
				Nahi.append(L[i])
				Nahi.append(j)
				Hash[j] = 1
				break
		if FLAG == 0:
			break
	if FLAG == 0:
		print('-1')
	else:
		for i in range(len(Nahi)):
			print(Nahi[i], end=' ')
		print()


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	if 2 * n in l:
		print(-1)
	else:
		t = []
		x = [0] * (2 * n + 1)
		f = 0
		for i in l:
			x[i] = 1
		for i in l:
			if 0 not in x[i:]:
				f = 1
				break
			else:
				p = x[i:].index(0)
				t.extend([i, p + i])
				x[p + i] = 1
		if f == 1:
			print(-1)
		else:
			for i in t:
				print(i, end=' ')
			print()


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	used = [False] * (2 * n + 1)
	a = [None] * (2 * n)
	possible = True
	for bi in b:
		used[bi] = True
	for i in range(2 * n):
		if i % 2 == 0:
			a[i] = b[i // 2]
		else:
			no = a[i - 1] + 1
			while no <= 2 * n and used[no]:
				no = no + 1
			if no > 2 * n:
				possible = False
				break
			else:
				a[i] = no
				used[no] = True
	if possible:
		print(*a)
	else:
		print(-1)


for i in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = []
	d = 0
	for i in range(1, 2 * n + 1):
		if i not in a:
			b.append(i)
	b.sort()
	c = []
	i = 0
	j = 0
	while len(b) > 0:
		if b[-1] < a[i]:
			d = 1
			break
		elif b[j] > a[i]:
			c.append(a[i])
			c.append(b[j])
			a.remove(a[i])
			b.remove(b[j])
			j = 0
		else:
			j += 1
		if j == len(b):
			break
	if d == 1:
		print(-1)
	else:
		print(*c)


from bisect import bisect_right
import sys
input = sys.stdin.readline
for ti in range(int(input().strip())):
	n = int(input().strip())
	b = [int(x) for x in input().strip().split()]
	n = list(range(1, 2 * n + 1))
	ans = []
	for bi in b:
		n.remove(bi)
	for bi in b:
		ai = bisect_right(n, bi)
		if ai == len(n):
			print('-1')
			break
		ans.append(bi)
		ans.append(n[ai])
		n.pop(ai)
	else:
		print(*ans)


for i in range(int(input())):
	n = int(input())
	b_array = list(map(int, input().split()))
	a_array = sorted(list(set(list(map(int, range(1, 2 * n + 1)))) - set(b_array)))
	sorted_array = sorted(list(map(list, list(zip(b_array, list(map(int, range(n))))))))
	final_array = [0] * (2 * n)
	state = True
	for j in range(2 * n):
		if j % 2 == 0:
			final_array[j] = b_array[int(j / 2)]
		else:
			final_array[j] = 0
	for j in range(n):
		if sorted_array[j][0] < a_array[j]:
			final_array[2 * sorted_array[j][1] + 1] = a_array[j]
		else:
			print(-1)
			state = False
			break
	if state == True:
		for j in range(n - 1):
			while True:
				k = 2
				p = -1
				while j * 2 + 1 + k < 2 * n:
					if final_array[j * 2] < final_array[j * 2 + 1 + k] and final_array[j * 2 + k] < final_array[j * 2 + 1] and (final_array[j * 2 + 1] > final_array[j * 2 + 1 + k]):
						p = j * 2 + 1 + k
					k += 2
				if p != -1:
					(final_array[j * 2 + 1], final_array[p]) = (final_array[p], final_array[j * 2 + 1])
				else:
					break
		print(' '.join(list(map(str, final_array))))


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	done = [0] * (2 * n + 1)
	if min(b) != 1 or max(b) == 2 * n:
		print(-1)
	else:
		ans = [0] * (2 * n + 1)
		for i in range(len(b)):
			done[b[i]] = 1
			ans[2 * i + 1] = b[i]
		for i in range(1, n + 1):
			for j in range(ans[2 * i - 1] + 1, 2 * n + 1):
				if done[j] == 0:
					ans[2 * i] = j
					done[j] = 1
					break
		if 0 in ans[1:]:
			print(-1)
		else:
			print(*ans[1:])


import bisect
for _ in range(int(input())):
	nb = int(input())
	b = [int(j) for j in input().split()]
	vis = [0 for i in range(nb * 2)]
	for i in range(nb):
		vis[b[i] - 1] = 1
	l = []
	for i in range(2 * nb):
		if not vis[i]:
			l.append(i + 1)
	ans = []
	for i in b:
		ind = bisect.bisect_left(l, i)
		if ind == len(l):
			print(-1)
			break
		else:
			ans.append(i)
			ans.append(l[ind])
			l.pop(ind)
	else:
		print(*ans)


def gen(b):
	a = list(range(1, 2 * n + 1))
	a = [x for x in a if x not in b]
	seq = []
	for b_ in b:
		try:
			idx = next((x for (x, v) in enumerate(a) if v > b_))
			seq += [b_, a[idx]]
			del a[idx]
		except:
			return None
	return seq
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	ans = gen(b)
	if ans:
		print(*ans)
	else:
		print(-1)


def is_in_array(value, array):
	l = 0
	r = len(array) - 1
	while l < r:
		mid = (l + r) // 2
		if array[mid] == value:
			return True
		elif array[mid] > value:
			l = mid + 1
		else:
			r = mid - 1
	return False
t = int(input())
for _ in range(t):
	n = int(input())
	values = [int(i) for i in input().split()]
	sorted_values = sorted(values)
	taken = [False] * (2 * n + 1)
	for x in values:
		taken[x] = True
	ans = [None] * 2 * n
	for i in range(n):
		ans[2 * i] = values[i]
		for j in range(values[i] + 1, 2 * n + 1):
			if not taken[j]:
				ans[2 * i + 1] = j
				taken[j] = True
				break
		else:
			print(-1)
			break
	else:
		print(' '.join(map(str, ans)))


t = int(input())
for _ in range(t):
	n = int(input())
	b = [int(x) for x in input().split()]
	v = set(list(range(1, 2 * n + 1)))
	for x in b:
		v.remove(x)
	l = list(v)
	l.sort()
	ans = [-1 for _a in range(2 * n)]
	ok = True
	for i in range(n):
		ans[2 * i] = b[i]
		ok = False
		for j in range(len(l)):
			if l[j] > b[i]:
				ans[2 * i + 1] = l[j]
				l.pop(j)
				ok = True
				break
		if ok == False:
			break
	if ok == False:
		print(-1)
	else:
		print(' '.join([str(x) for x in ans]))


from collections import defaultdict
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	b = list(map(lambda x: x - 1, b))
	flag = [False] * (2 * n)
	for bi in b:
		flag[bi] = True
	pair = defaultdict(int)
	f = True
	for bi in b:
		for i in range(bi + 1, 2 * n):
			if not flag[i]:
				pair[bi] = i
				flag[i] = True
				break
		else:
			f = False
	if not f:
		print(-1)
		continue
	ans = []
	for bi in b:
		ans.append(min(bi, pair[bi]))
		ans.append(max(bi, pair[bi]))
	ans = list(map(lambda x: x + 1, ans))
	print(*ans)


t = int(input())
while t > 0:
	t -= 1
	n = int(input())
	a = list(map(int, input().split()))
	x = []
	for i in range(n):
		x.append(a[i])
		k = a[i] + 1
		q = True
		while q == True:
			if k in a or k in x:
				k = k + 1
			else:
				q = False
				break
		x.append(k)
	if max(x) == 2 * n:
		for i in range(len(x)):
			print(x[i], end=' ')
		print(' ')
	else:
		print(-1)


from bisect import bisect_right
t = int(input())
for _ in range(t):
	n = int(input())
	b = [int(x) for x in input().split()]
	arr = [False] * (2 * n + 1)
	result = [0] * (n * 2)
	for (i, val) in enumerate(b):
		result[i * 2] = val
		arr[val] = True
	arr[0] = True
	arr = [i for (i, v) in enumerate(arr) if v == False]
	arr = sorted(arr)
	err = False
	for i in range(n):
		j = bisect_right(arr, result[i * 2])
		if j == len(arr):
			err = True
			break
		result[2 * i + 1] = arr[j]
		arr.pop(j)
	if err:
		print('-1')
	else:
		print(' '.join(map(str, result)))


t = int(input())

def f():
	n = int(input())
	b = list(map(int, input().split()))
	a = [b[i // 2] if i % 2 == 0 else 0 for i in range(n * 2)]
	used = 2 * n * [0] + [0]
	for i in a:
		used[i] = 1
	for i in range(1, 2 * n, 2):
		l = a[i - 1]
		j = l + 1
		while j <= 2 * n and used[j]:
			j += 1
		if j > 2 * n:
			print(-1)
			return
		a[i] = j
		used[j] = 1
	print(*a)
for tt in range(t):
	f()


for _ in range(int(input())):
	n = int(input())
	array = list(map(int, input().split()))
	dick = {}
	for i in array:
		dick[i] = 1
	ans = [0] * (2 * n)
	for i in range(n):
		ans[2 * i] = array[i]
	flag = True
	for i in range(n):
		k = ans[2 * i]
		klag = False
		for j in range(k + 1, 2 * n + 1):
			if dick.get(j, 0) == 0:
				dick[j] = 1
				klag = True
				ans[2 * i + 1] = j
				break
		if klag == False:
			flag = False
			break
	if not flag:
		print(-1)
	else:
		print(*ans)


import sys
import bisect
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().rstrip().split())
inl = lambda : list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
t = ini()
for _ in range(t):
	n = ini()
	b = inl()
	a = [i for i in range(1, n * 2 + 1) if i not in b]
	out = True
	for (index, number) in enumerate(sorted(b)):
		if number > a[index]:
			out = False
			print(-1)
			break
	if not out:
		continue
	ans = []
	for i in b:
		x = bisect.bisect_right(a, i)
		ans.append(i)
		ans.append(a[x])
		a.pop(x)
	print(*ans)


n = int(input())
while n:
	n = n - 1
	a = int(input())
	b = list(map(int, input().split()))
	c = [True for x in range(2 * a + 1)]
	for x in b:
		c[x] = False
	ans = []
	get = True
	for i in range(a):
		flag = False
		k = b[i]
		while k < 2 * a + 1:
			if c[k] == True:
				flag = True
				c[k] = False
				ans.append(b[i])
				ans.append(k)
				break
			else:
				k += 1
		if flag == False:
			get = False
			break
	if get:
		for x in ans:
			print(x, end=' ')
		print('\n', end='')
	else:
		print('-1')


def STR():
	return list(input())

def INT():
	return int(input())

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

def MAP2():
	return map(float, input().split())

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

def STRING():
	return input()
import string
import sys
from heapq import heappop, heappush
from bisect import *
from collections import deque, Counter, defaultdict
from math import *
from itertools import permutations, accumulate
dx = [-1, 1, 0, 0]
dy = [0, 0, 1, -1]
for tt in range(INT()):
	n = INT()
	arr = LIST()
	freq = [0] * (2 * n + 1)
	for i in arr:
		freq[i] = 1
	flag = True
	ans = []
	for i in range(n):
		for j in range(arr[i], 2 * n + 1):
			if j > arr[i] and freq[j] == 0:
				ans.append(arr[i])
				ans.append(j)
				freq[j] = 1
				break
	k = list(ans)
	if len(ans) < 2 * n:
		print('-1')
	else:
		ans.sort()
		for i in range(1, 2 * n + 1):
			if i != ans[i - 1]:
				flag = False
				break
		if flag:
			print(*k)
		else:
			print(-1)


t = int(input(''))
for _ in range(t):
	n = int(input(''))
	tst = list(map(int, input().split()))
	b = [0]
	for i in tst:
		b.append(i)
	a = [0] * (2 * n + 1)
	used = [0] * (2 * n + 1)
	khaise = 0
	for i in range(1, n + 1):
		a[2 * (i - 1) + 1] = b[i]
		if used[b[i]]:
			khaise = 1
		used[b[i]] = 1
	for i in range(2, 2 * n + 1, 2):
		for j in range(a[i - 1], 2 * n + 1, 1):
			if 1 - used[j]:
				break
		if j > 2 * n:
			khaise = 1
		a[i] = j
		used[j] = 1
	for i in range(1, 2 * n + 1):
		if 1 - used[i]:
			khaise = 1
	if khaise:
		print(-1)
	else:
		print(*a[1:])


import bisect
import collections
t = int(input())
for test in range(t):
	canDo = True
	n = int(input())
	b = []
	a = list(range(1, 2 * n + 1))
	for i in input().split():
		b.append(int(i))
		a.remove(int(i))
	a.sort()
	c = []
	for (i, elem) in enumerate(b):
		placeholder = bisect.bisect_left(a, elem)
		if placeholder == len(a):
			canDo = False
			break
		else:
			c.append(str(b[i]))
			c.append(str(a[placeholder]))
			del a[placeholder]
	if not canDo:
		print(-1)
		continue
	print(' '.join(c))


for _ in range(int(input())):
	n = int(input())
	b = [int(x) for x in input().split()]
	a = []
	for i in range(n):
		a.append(b[i])
		k = b[i]
		while k in a or k in b:
			k += 1
		if k > 2 * n:
			print(-1)
			break
		a.append(k)
	else:
		print(*a)


def main():
	for _ in range(int(input())):
		n = int(input())
		a = list(map(int, input().split()))
		t = 0
		ans = []
		used = [0] * (2 * n + 1)
		for i in range(n):
			used[a[i]] += 1
			if used[a[i]] == 2:
				t = 1
				ans = -1
				break
		if t:
			print(-1)
			continue
		var = []
		for i in range(1, 2 * n + 1):
			if not used[i]:
				var.append(i)
		ans = []
		used = [0] * (2 * n + 1)
		for i in range(n):
			cur = a[i]
			add = -1
			for j in range(n):
				if var[j] > cur and (not used[var[j]]):
					add = var[j]
					used[var[j]] = 1
					break
			if add == -1:
				t = 1
				break
			ans.append(cur)
			ans.append(var[j])
		if t:
			print(-1)
			continue
		print(*ans)
main()


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	ans = []
	a = 0
	for i in range(n):
		ans.append(l[i])
		c = l[i]
		while c in l or c in ans:
			c += 1
		if c > 2 * n:
			a = -1
			break
		ans.append(c)
	if a == -1:
		print(-1)
	else:
		print(*ans)


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	check = [True] * (2 * n)
	for i in range(n):
		check[a[i] - 1] = False
	res = []
	right = []
	for (idx, value) in enumerate(a):
		res.append(value)
		i = value - 1
		while i < 2 * n and (not check[i]):
			i += 1
		if i < 2 * n:
			check[i] = False
			res.append(i + 1)
		else:
			res = [-1]
			break
	print(*res)


from bisect import bisect_right
for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	try:
		a = [0] * 2 * n
		a[::2] = b.copy()
		m = sorted(set(range(1, 2 * n + 1)).difference(set(b))) + [float('inf')]
		for i in range(1, 2 * n, 2):
			a[i] = m.pop(bisect_right(m, a[i - 1]))
		if list(range(1, 2 * n + 1)) != sorted(a):
			print(-1)
		else:
			print(*a)
	except:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	lst = [int(i) for i in input().split()]
	s = {*range(2 * n + 1)} - {*lst}
	a = []
	try:
		for i in lst:
			minn = min(s - {*range(i)})
			s -= {minn}
			a += (i, minn)
	except:
		a = (-1,)
	print(*a)


a = int(input())
for i in range(a):
	n = int(input())
	z = list(map(int, input().split()))
	t = [0 for i in range(3 * max(z))]
	ans = []
	for i in range(len(z)):
		if t[z[i]] == 0:
			t[z[i]] = 1
	for i in range(len(z)):
		ans.append(z[i])
		for j in range(z[i] + 1, len(t)):
			if t[j] == 0:
				t[j] = 1
				ans.append(j)
				break
	t = sorted(ans)
	flag = 0
	for i in range(len(t)):
		if t[i] != i + 1:
			flag = 1
			break
	if flag == 1:
		print(-1)
	else:
		print(' '.join(map(str, ans)))


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = []
	rem = set([i for i in range(1, 2 * n + 1)]) - set(b)
	f = True
	for i in range(n):
		a.append(b[i])
		ai = float('inf')
		for j in rem:
			if j > b[i] and ai > j:
				ai = j
		if ai == float('inf'):
			f = False
			break
		rem.remove(ai)
		a.append(ai)
	if f:
		print(*a)
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	b = [int(__) for __ in input().split()]
	shit = list(range(1, 2 * n + 1))
	ans = []
	flag = 1
	for i in b:
		shit.remove(i)
	for i in b:
		for j in shit:
			if j > i:
				ans.append(i)
				ans.append(j)
				shit.remove(j)
				flag = 1
				break
			else:
				flag = 0
		if flag == 0:
			break
	if flag == 0:
		print(-1)
	else:
		for i in ans:
			print(i, end=' ')
		print('')


from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
from math import *
from collections import defaultdict as dd, deque

def data():
	return sys.stdin.readline().strip()

def mdata():
	return map(int, data().split())
for i in range(int(input())):
	n = int(data())
	b = list(mdata())
	l = []
	for i in range(1, 2 * n + 1):
		if i not in b:
			l.append(i)
	l1 = []
	for i in range(n):
		flag = False
		for j in range(len(l)):
			if b[i] < l[j]:
				l1.append(b[i])
				l1.append(l[j])
				l.pop(j)
				flag = True
				break
		if flag == False:
			break
	if flag == True:
		print(*l1)
	else:
		print(-1)


t = int(input())
for x in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	numbers_used = [False for i in range(2 * n)]
	a = []
	for i in b:
		numbers_used[i - 1] = True
	for i in b:
		a.append(i)
		for j in range(i, 2 * n):
			if numbers_used[j] == False:
				numbers_used[j] = True
				a.append(j + 1)
				break
		if a[-1] == i:
			a = [-1]
			break
	print(*a)


for _ in range(int(input())):
	n = int(input())
	br = list(map(int, input().split()))
	ar = [0] * 2 * n
	for i in range(0, 2 * n, 2):
		ar[i] = br[i // 2]
	se = set(br)
	for i in range(0, 2 * n, 2):
		for k in range(ar[i] + 1, 3 * n):
			if not k in se:
				ar[i + 1] = k
				se.add(k)
				break
	bbc = ar.copy()
	bbc.sort()
	ccr = []
	for zz in range(1, 2 * n + 1):
		ccr.append(zz)
	if bbc == ccr:
		print(*ar)
	else:
		print(-1)


import bisect
import sys
import math
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	a = [0] * (2 * n)
	j = 0
	ind = [0] * (2 * n + 1)
	for i in range(n):
		ind[l[i]] = 1
	for i in range(n):
		a[j] = l[i]
		j += 2
	j = 1
	while j < 2 * n:
		for i in range(a[j - 1] + 1, 2 * n + 1):
			if ind[i] == 0:
				ind[i] = 1
				a[j] = i
				break
		j += 2
	ch = 1
	for i in range(2 * n):
		if a[i] == 0:
			ch = 0
	if ch == 0:
		print(-1)
	else:
		print(*a)


for _ in range(int(input())):
	n = int(input())
	seq = list(map(int, input().split()))
	if len(set(seq)) != n or max(seq) > 2 * n - 1:
		print(-1)
		continue
	myst = set(range(1, 2 * n + 1)) - set(seq)
	myst = list(sorted(myst))
	ans = []
	fl = True
	for x in seq:
		upbnd = 0
		while upbnd < len(myst) and myst[upbnd] < x:
			upbnd += 1
		if upbnd == len(myst):
			fl = False
			break
		ans.append(x)
		ans.append(myst[upbnd])
		myst.pop(upbnd)
	if not fl:
		print(-1)
	else:
		print(*ans)


cases = int(input())
final = []
for _ in range(cases):
	n = int(input())
	mm = []
	flag = 0
	c = list(map(int, input().split()))
	v = list(set(list(range(1, 2 * len(c) + 1))) - set(c))
	mm = []
	for i in range(len(v)):
		r = c[i]
		try:
			q = min([v[i] for i in range(len(v)) if v[i] > r])
			mm.append(q)
			v.remove(q)
		except:
			continue
	gg = []
	for i in range(len(mm)):
		gg.append(c[i])
		gg.append(mm[i])
	if len(gg) == 2 * len(c):
		print(*gg)
	else:
		print(-1)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
for _ in range(get_int()):
	n = get_int()
	b = get_list()
	l = 2 * n + 1
	done = [0] * l
	for i in b:
		done[i] = 1
	ans = []
	for i in b:
		ans.append(i)
		for j in range(i + 1, l):
			if done[j] == 0:
				done[j] = 1
				ans.append(j)
				break
		else:
			print(-1)
			break
	else:
		print(*ans)


def oki(n, lst):
	tm = []
	for i in range(1, 2 * n + 1):
		if i not in lst:
			tm.append(i)
	out = []
	for i in lst:
		temp = None
		for j in range(i + 1, 2 * n + 1):
			if j in tm:
				temp = j
				break
		if temp == None:
			out = []
			break
		out.append(i)
		out.append(j)
		tm.remove(temp)
	if out:
		print(*out)
	else:
		print('-1')
for _ in range(int(input())):
	n = int(input())
	lst = list(map(int, input().split(' ')))
	oki(n, lst)


def find(st, num):
	mn = -1
	for i in st:
		if mn == -1:
			if i > num:
				mn = i
		elif num < i < mn:
			mn = i
	return mn

def main():
	n = int(input())
	st = set()
	for i in range(1, n * 2 + 1):
		st.add(i)
	lst = list(map(int, input().split()))
	for i in lst:
		if not i in st:
			break
		st.remove(i)
	line = ''
	for i in lst:
		elem = find(st, i)
		if elem == -1:
			print(-1)
			return
		line += str(i) + ' ' + str(elem) + ' '
		st.remove(elem)
	print(line)
t = int(input())
for i in range(t):
	main()


def main(n, b):
	tab = [0] * (2 * n)
	dispo = [True] * (2 * n + 1)
	for i in range(n):
		tab[2 * i] = b[i]
		dispo[b[i]] = False
	for i in range(n):
		j = b[i]
		test = True
		while j <= 2 * n and test:
			if not dispo[j]:
				j += 1
			else:
				test = False
				dispo[j] = False
		tab[2 * i + 1] = j
	test = True
	for i in range(1, 2 * n + 1):
		if dispo[i]:
			test = False
	if not test:
		print(-1)
	else:
		mot = ''
		for x in tab:
			mot += str(x) + ' '
		print(mot)
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	main(n, b)


t = int(input())
for p in range(t):
	n = int(input())
	a = []
	b = list(map(int, input().split()))
	if max(b) >= 2 * n:
		print('-1')
	else:
		for i in range(2 * n):
			if i % 2 == 0:
				m = b[i // 2]
				a.append(m)
			else:
				a.append(0)
		c = 1
		z = 0
		for i in range(0, 2 * n):
			temp = 0
			if a[i] == 0:
				s = a[i - 1] + 1
				if s not in a:
					a[i] = s
				else:
					for z in range(s, 2 * n + 1):
						if z not in a:
							a[i] = z
							break
		if 0 in a:
			print('-1')
		else:
			for i in range(2 * n):
				print(a[i], end=' ')
			print()


t = int(input())
for x in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	count = 0
	a = 0
	out = []
	fail = False
	while a < n:
		out.append(arr[a])
		count = out[-1]
		while count < 2 * n:
			count += 1
			if not count in arr and (not count in out):
				if count > arr[a]:
					out.append(count)
					count = 2 * n + 10
		if out[-1] == arr[a]:
			fail = True
			a = 2 * n + 1
		a += 1
	if fail:
		print(int(-1))
	else:
		print(*out)


t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	done = l[:]
	result = []
	for i in range(n):
		val = l[i]
		flag = 0
		for j in range(val + 1, 2 * n + 1):
			if j not in done:
				done.append(j)
				result.extend([val, j])
				flag = 1
				break
		if flag != 1:
			break
	if flag == 0:
		print(-1)
	else:
		print(*result, sep=' ')


for _ in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	d = {}
	for i in range(n):
		d[a[i]] = 1
	ans = []
	f = 0
	for i in range(n):
		if a[i] < 2 * n:
			for j in range(a[i], 2 * n + 2):
				if not d.get(j) and j <= 2 * n:
					ans.append(a[i])
					ans.append(j)
					d[j] = 1
					break
				if j > 2 * n:
					print(-1)
					f = 1
					break
		else:
			print(-1)
			f = 1
			break
		if f == 1:
			break
	if f == 0:
		for i in ans:
			print(i, end=' ')
		print()


for T in range(int(input())):
	n = int(input())
	x = list(map(int, input().split(' ')))
	b = [0]
	for i in x:
		b.append(i)
	vis = [False for cnt_used in range(2 * n + 1)]
	a = [0 for cnt_a in range(2 * n + 1)]
	set_elem_b = True
	for i in range(1, n + 1):
		num = int(b[i])
		if not vis[num]:
			vis[num] = True
		else:
			set_elem_b = False
			break
	if not set_elem_b:
		print(-1)
		continue
	find = False
	for i in range(1, n + 1):
		find = False
		for j in range(1, 2 * n + 1):
			if not vis[j] and j > b[i]:
				vis[j] = True
				a[i * 2 - 1] = b[i]
				a[i * 2] = j
				find = True
				break
		if not find:
			break
	if not find:
		print(-1)
		continue
	for i in range(1, 2 * n + 1):
		print(a[i], end=' ')
	print()


import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from heapq import heappush, heappop, heapify, nlargest, nsmallest

def STR():
	return list(input())

def INT():
	return int(input())

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

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def sortListWithIndex(listOfTuples, idx):
	return sorted(listOfTuples, key=lambda x: x[idx])

def sortDictWithVal(passedDic):
	temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))[::-1]
	toret = {}
	for tup in temp:
		toret[tup[0]] = tup[1]
	return toret

def sortDictWithKey(passedDic):
	return dict(OrderedDict(sorted(passedDic.items())))
INF = float('inf')
mod = 10 ** 9 + 7
t = INT()
while t != 0:
	n = INT()
	b = LIST()
	if 1 not in b or 2 * n in b:
		print(-1)
	else:
		left = []
		for i in range(1, 2 * n + 1):
			if i not in b:
				left.append(i)
		left.sort()
		final = []
		for i in range(n):
			flag = 0
			for (j, el) in enumerate(left):
				if el > b[i]:
					final.append(b[i])
					final.append(el)
					flag = 1
					break
			if flag == 1:
				left.pop(j)
			else:
				break
		if flag == 0:
			print(-1)
		else:
			print(*final)
	t -= 1


t = int(input())
while t:
	t -= 1
	n = int(input())
	b = list(map(int, input().split()))
	cpy = b[:]
	s = list(set(range(1, 2 * n + 1)) - set(b))
	s.sort()
	cpy.sort()
	d = dict()
	for (val, k) in enumerate(cpy):
		d[k] = val
	ans = []
	flag = True
	for i in b:
		val = 0
		for j in s:
			if i < j:
				val = j
				s.remove(j)
				break
		if val:
			ans.append(i)
			ans.append(val)
		else:
			flag = False
			break
	if flag:
		print(*ans)
	else:
		print('-1')


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	p = list(range(1, 2 * n + 1))
	inb = set(b)
	a = {}
	for (i, v) in enumerate(b):
		if v == 2 * n:
			print(-1)
			break
		c = [z for z in p[p.index(v) + 1:] if z not in inb]
		if len(c) == 0:
			print(-1)
			break
		i += 1
		a[2 * i - 1] = v
		a[2 * i] = c[0]
		p.remove(v)
		p.remove(c[0])
	else:
		string = ''
		for i in range(1, 2 * n + 1):
			string += str(a[i]) + ' '
		print(string)


from bisect import bisect_left as bl
from bisect import bisect_right as br
import heapq
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 10 ** 9 + 7

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip('\n').split(' ')]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n').split(' ')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
for _ in range(val()):
	n = val()
	b = li()
	a = [0 for i in range(2 * n)]
	for i in range(n):
		a[2 * i] = b[i]
	s = set([i for i in range(1, 2 * n + 1)])
	for i in b:
		s.remove(i)
	for i in range(1, 2 * n, 2):
		temp = a[i - 1]
		while temp + 1 not in s and temp + 1 <= 2 * n:
			temp += 1
		temp += 1
		if temp == 2 * n + 1:
			ans = -1
			a = -1
			break
		a[i] = temp
		s.remove(temp)
	if a != -1:
		print(*a)
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0 for i in range(2 * n)]
	for i in range(n):
		a[2 * i] = b[i]
	rec = {}
	avail = [1 for i in range(1, 2 * n + 1)]
	for i in b:
		avail[i - 1] = 0
	glob = 1
	for i in range(n):
		pos = 2 * i + 1
		flag = 0
		for j in range(a[2 * i], 2 * n):
			if avail[j] == 1:
				flag = 1
				a[pos] = j + 1
				avail[j] = 0
				break
		if flag == 0:
			glob = 0
			break
	if glob == 0:
		print(-1)
	else:
		for i in a:
			print(i, end=' ')
		print('')


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
import random
from queue import PriorityQueue
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f

def ncr(x, y):
	return f(x) // (f(y) * f(x - y))
t = int(input())
for _ in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	seti = set((i for i in range(1, 2 * n + 1)))
	set1 = set((i for i in l))
	ans = []
	flag = 0
	ba = [i for i in range(1, 2 * n + 1)]
	for i in range(n):
		z = l[i]
		if z not in seti:
			flag = 1
			break
		else:
			seti.remove(z)
			ans.append(z)
			ka = len(ans)
			for j in ba:
				if j > z and j in seti and (j not in set1):
					ans.append(j)
					seti.remove(j)
					break
			if len(ans) == ka:
				flag = 1
				break
	if flag == 1:
		print(-1)
	else:
		print(*ans)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_int = lambda : int(sys.stdin.readline())
for _ in range(get_int()):
	n = get_int()
	lst1 = get_list()
	lst2 = [i for i in range(1, 2 * n + 1) if i not in lst1]
	res = [0] * (2 * n)
	valid = True
	for i in range(n):
		a = lst1[i]
		b = -1
		for j in range(n):
			if lst2[j] > a:
				b = lst2[j]
				lst2[j] = 0
				break
		if b == -1:
			valid = False
			break
		(res[2 * i], res[2 * i + 1]) = (a, b)
	if valid:
		print(*res)
	else:
		print(-1)


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	c = set(b)
	l = []
	valid = True
	for i in b:
		temp = i + 1
		while temp in c:
			temp += 1
		if temp > 2 * n:
			print(-1)
			valid = False
			break
		l += [i, temp]
		c.add(temp)
	if valid:
		print(' '.join(map(str, l)))


I = lambda : map(int, input().split())
for _ in [0] * int(input()):
	n = int(input())
	b = list(I())
	ff = 0
	a = [0] * (2 * n)
	for i in range(0, 2 * n, 2):
		x = b[i // 2]
		a[i] = x
		x = x + 1
		while x in b:
			x = x + 1
		if x > 2 * n:
			ff = 1
			break
		a[i + 1] = x
		b.append(x)
	if ff == 0:
		print(*a)
	else:
		print(-1)


from bisect import bisect_left
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	dif = [0] * (n - 1)
	if 1 not in b:
		print(-1)
	elif max(b) >= 2 * n:
		print(-1)
	else:
		ans = [0] * (2 * n)
		base = list(range(1, n * 2 + 1))
		for i in range(n):
			ans[i * 2] = b[i]
			base.remove(b[i])
		for i in range(n):
			index = bisect_left(base, ans[i * 2])
			if index == len(base):
				print(-1)
				break
			ans[i * 2 + 1] = base.pop(index)
		else:
			print(*ans)


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	n = int(input())
	m = 2 * n
	v = [0] * m
	a = list(map(int, input().split()))
	if max(a) == m:
		print(-1)
	else:
		k = 1
		d = []
		for i in a:
			v[i - 1] = 1
		for i in range(n):
			d.append(a[i])
			p = a[i] - 1
			while v[p] != 0:
				p += 1
				if p == m:
					print(-1)
					k = 0
					break
			if not k:
				break
			v[p] = 1
			d.append(p + 1)
		if k:
			print(*d)


for tc in range(int(input())):
	n = int(input())
	b = list(map(int, input().split(' ')))
	b.insert(0, 0)
	a = (2 * n + 1) * [0]
	s = set()
	flag = True
	for i in range(1, n + 1):
		a[2 * i - 1] = b[i]
		if b[i] in s:
			flag = False
			break
		s.add(b[i])
	for i in range(1, len(b)):
		val = b[i] + 1
		while val in s:
			val += 1
		a[2 * i] = val
		s.add(val)
	for i in range(1, 2 * n + 1):
		if not i in s:
			flag = False
			break
	if flag:
		print(*a[1:])
	else:
		print(-1)


def solve(n, l):
	li = [0 for i in range(2 * n)]
	j = 0
	i = 0
	while j < n:
		li[i] = l[j]
		j += 1
		i += 2
	d = {}
	for k in l:
		d[k] = True
	k = 1
	while k < 2 * n:
		val = li[k - 1] + 1
		while d.get(val) and val <= 2 * n:
			val += 1
		if val > 2 * n:
			return -1
		d[val] = True
		li[k] = val
		k += 2
	return ' '.join(map(str, li))
for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	print(solve(n, l))


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	a = []
	dic = {}
	for i in b:
		dic[i] = 1
	for i in b:
		a.append(i)
		x = i + 1
		while True:
			if x in dic:
				x += 1
			else:
				break
		a.append(x)
		dic[x] = 1
	f = True
	for i in range(1, 2 * n + 1):
		if i in dic:
			continue
		else:
			f = False
			break
	if f:
		print(*a)
	else:
		print(-1)


t = int(input())
for i in range(t):
	op = []
	n = int(input())
	x = list(input().split())
	xi = [int(i) for i in x]
	for j in range(2 * n):
		if j % 2 == 0:
			t = xi[j // 2]
			op.append(t)
		else:
			op.append(0)
	xx = 1
	for j in range(n):
		z = op[xx - 1] + 1
		if z in op:
			for q in range(z + 1, 2 * n + 1):
				if q not in op:
					op[xx] = q
					break
		else:
			op[xx] = z
		xx += 2
	if max(op) > 2 * n:
		print('-1')
	elif 0 in op:
		print('-1')
	else:
		for j in range(len(op)):
			print(op[j], end=' ')
		print()


for _ in range(int(input())):
	n = int(input())
	lst = list(map(int, input().split()))
	lst2 = []
	for i in range(1, 2 * n + 1):
		lst2.append(i)
	if max(lst) < len(lst):
		print(-1)
	else:
		for i in lst:
			lst2.remove(i)
		lst3 = []
		lst4 = [False] * n
		for i in lst:
			for j in lst2:
				if i < j and lst4[lst2.index(j)] == False:
					lst3.append(i)
					lst3.append(j)
					lst4[lst2.index(j)] = True
					break
		if len(lst3) == 2 * n:
			print(' '.join(map(str, lst3)))
		else:
			print(-1)


import math
from sys import stdin as c
n = int(input())
a = []
for i in range(n):
	input()
	a.append(list(map(int, c.readline().split(' '))))

def higher(ar, val):
	u = len(ar) - 1
	if u == 0:
		return 0
	if u == -1:
		return -1
	elif ar[u // 2] > val:
		return higher(ar[:u // 2 + 1], val)
	else:
		u1 = higher(ar[u // 2 + 1:], val)
		if u1 > -1:
			u1 += u // 2 + 1
		return u1
for i in a:
	n = len(i)
	s = set(i)
	n2 = set(range(1, 2 * n + 1))
	n2 -= s
	d = dict(zip(i, range(n)))
	n2 = list(n2)
	if n != len(n2):
		print(-1)
		continue
	odp = []
	b = True
	for j in range(n):
		h = higher(n2, i[j])
		if i[j] < n2[h]:
			odp.append(i[j])
			odp.append(n2[h])
			del n2[h]
		else:
			print(-1)
			b = False
			break
	if b:
		print(*odp)


def main():
	for t in range(int(input())):
		n = int(input())
		s = [i for i in range(1, 2 * n + 1)]
		l = [int(j) for j in input().split()]
		for i in range(n):
			s.remove(l[i])
		z = list(zip(l, [i for i in range(n)]))
		s.sort()
		ans = [0] * (2 * n)
		for i in range(n):
			num = z[i][0]
			for j in s:
				if j > num:
					ans[2 * z[i][1]] = num
					ans[2 * z[i][1] + 1] = j
					s.remove(j)
					break
			else:
				print(-1)
				break
		else:
			print(' '.join(map(str, ans)))
main()


t = int(input())
for i in range(t):
	n = int(input())
	nums = list(map(int, input().split()))
	ans = [0] * (2 * n)
	for i in range(0, n * 2, 2):
		ans[i] = nums[i // 2]
	left = sorted(set(range(1, 2 * n + 1)) - set(nums))
	for j in range(1, n * 2, 2):
		for k in left:
			if k > ans[j - 1]:
				ans[j] = k
				left.remove(k)
				break
	if 0 in ans:
		print(-1)
	else:
		print(' '.join(list(map(str, ans))))


for _ in range(int(input())):
	n = int(input())
	u = False
	s = []
	k = []
	l = list(map(int, input().split()))
	for i in range(1, 2 * n + 1):
		if i not in l:
			k.append(i)
	for i in range(n):
		s.append(l[i])
		for j in range(len(k)):
			if k[j] > l[i]:
				s.append(k[j])
				del k[j]
				u = True
				break
		if not u:
			print('-1')
			break
	if u and len(s) == 2 * n:
		print(*s, sep=' ')
	elif u:
		print('-1')


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	s = set()
	for i in range(1, 2 * n + 1):
		s.add(i)
	for i in arr:
		s.discard(i)
	a = []
	b = True
	for i in arr:
		if i + 1 > 2 * n:
			b = False
		elif i + 1 in s:
			a += [i + 1]
			s.discard(i + 1)
		else:
			c = False
			for t in s:
				if t > i:
					a += [t]
					s.discard(t)
					c = True
					break
			if not c:
				b = False
				break
	if not b:
		print(-1)
	else:
		for i in range(n):
			print(arr[i], a[i], end=' ')


from math import *

def binarySearch(arr, x, i):
	l = i
	r = len(arr) - 1
	while l <= r:
		mid = (l + r) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] < x:
			l = mid + 1
		else:
			r = mid - 1
	return -1

def js(arr, x):
	l = 0
	r = len(arr) - 1
	ans = -1
	while l <= r:
		m = (l + r) // 2
		if arr[m] <= x:
			ans = m
			l = m + 1
		else:
			r = m - 1
	return ans

def jg(arr, x):
	l = 0
	r = len(arr) - 1
	ans = -1
	while l <= r:
		m = (l + r) // 2
		if arr[m] >= x:
			ans = m
			r = m - 1
		else:
			l = m + 1
	return ans

def ceil(a, b):
	if a % b == 0:
		return int(a / b)
	else:
		return a // b + 1

def c(s, i, a, b):
	count = 0
	for j in range(i, len(s)):
		if s[i] != s[j]:
			if s[i] == 'A':
				count += a
			else:
				count += b
			i = j
	if i < len(s) - 1:
		if s[i] == 'A':
			count += a
		else:
			count += b
	return count
for __ in range(int(input())):
	n = int(input())
	ar = list(map(int, input().split()))
	h = [0] * (2 * n + 1)
	ans = [0] * (2 * n + 1)
	for i in range(n):
		h[ar[i]] = 1
	for i in range(n):
		ans[2 * (i + 1) - 1] = ar[i]
		f = -1
		for j in range(ar[i], 2 * n + 1):
			if h[j] == 0:
				f = j
				h[j] = 1
				break
		if f == -1:
			break
		else:
			ans[2 * (i + 1)] = j
	if f == -1:
		print(-1)
	else:
		print(*ans[1:])


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
for _ in range(INT()):
	N = INT()
	B = LIST()
	A = [0] * (N * 2)
	S = set()
	for i in range(N):
		A[i * 2] = B[i]
		S.add(B[i])
	for i in range(N):
		b = A[i * 2]
		for j in range(b + 1, N * 2 + 1):
			if j not in S:
				A[i * 2 + 1] = j
				S.add(j)
				break
	for i in range(N):
		if A[i * 2] > A[i * 2 + 1]:
			print(-1)
			break
	else:
		print(*A)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import factorial
from collections import Counter, defaultdict
from heapq import heapify, heappop, heappush

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def N():
	return int(input())

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 1000000007
INF = float('inf')

def main():
	for _ in range(N()):
		n = N()
		arr = list(RL())
		rec = [0] * (2 * n + 1)
		res = [0] * (2 * n)
		for i in range(n):
			rec[arr[i]] = 1
		tag = False
		for i in range(0, 2 * n, 2):
			res[i] = arr[i // 2]
			for j in range(arr[i // 2] + 1, 2 * n + 1):
				if rec[j] != 1:
					rec[j] = 1
					res[i + 1] = j
					break
			else:
				tag = True
				break
			if tag:
				break
		if tag:
			print(-1)
		else:
			print(*res)
main()


for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	tree = list(range(2 * n + 10))

	def find(st):
		if tree[st] != st:
			tree[st] = find(tree[st])
		return tree[st]
	for c in arr:
		tree[find(c)] = find(c + 1)
	ans = [0] * (2 * n)
	for i in range(0, 2 * n, 2):
		ans[i] = arr[i // 2]
	f = True
	for i in range(1, 2 * n, 2):
		d = ans[i - 1]
		ans[i] = find(d)
		tree[ans[i]] = find(ans[i] + 1)
		if ans[i] > 2 * n:
			f = False
			break
	if f:
		print(*ans)
	else:
		print(-1)


from collections import Counter
from collections import defaultdict
import math
t = int(input())
for _ in range(0, t):
	n = int(input())
	a = list(map(int, input().split()))
	l = list()
	k = 1
	d = defaultdict(lambda : 0)
	for i in range(0, n):
		d[a[i]] = 1
	for i in range(0, n):
		f = 0
		for j in range(a[i] + 1, 2 * n + 1):
			if d[j] == 0:
				f = 1
				d[j] = 1
				l.append(a[i])
				l.append(j)
				break
		if f == 0:
			k = 0
			print(-1)
			break
	if k == 1:
		print(*l)


import sys
input = sys.stdin.readline
Q = int(input())
Query = []
for _ in range(Q):
	N = int(input())
	A = list(map(int, input().split()))
	Query.append((N, A))
for (N, A) in Query:
	S = set(A)
	C = set()
	for n in range(1, 2 * N + 1):
		if not n in S:
			C.add(n)
	ans = []
	for a in A:
		to = -1
		for n in range(a + 1, 2 * N + 1):
			if n in C:
				to = n
				break
		if to == -1:
			ans = []
			break
		ans.append(a)
		ans.append(to)
		C.remove(to)
	if not ans:
		print(-1)
	else:
		print(*ans)


import sys
from collections import defaultdict, deque
inp = sys.stdin.readline
read = lambda : list(map(int, inp().split()))

def a():
	ans = ''
	for _ in range(read()[0]):
		(a, b, x, y) = read()
		x += 1
		y += 1
		ans += str(max((a - x) * b, (x - 1) * b, a * (b - y), a * (y - 1))) + '\n'
	print(ans)

def c():
	ans = ''
	for _ in range(read()[0]):
		flag = 0
		n = int(inp())
		dic = dict()
		for (ind, elem) in enumerate(read()):
			dic[elem] = (ind * 2, ind * 2 + 1)
		arr = [None] * (2 * n)
		left = set((i for i in range(1, 2 * n + 1))).difference(dic.keys())
		for i in dic.keys():
			elem = dic[i]
			mins = [y for y in left if y > i]
			if mins:
				sup = min(mins)
				(arr[elem[0]], arr[elem[1]]) = (i, sup)
				left.remove(sup)
			else:
				flag = 1
				break
		if flag:
			ans += '-1\n'
		else:
			ans += ' '.join(map(str, arr)) + '\n'
	print(ans)
c()


from collections import defaultdict as dfd
for _ in range(int(input())):
	N = int(input())
	A = list(map(int, input().split()))
	C = dfd(int)
	for i in range(1, 2 * N + 1):
		C[i] = 0
	for i in range(len(A)):
		C[A[i]] = 1
	B = []
	for i in range(len(A)):
		B.append(A[i])
		z = 0
		temp = A[i] + 1
		while z != 1:
			if C[temp] == 0:
				C[temp] = 1
				B.append(temp)
				z = 1
			else:
				temp += 1
	res = 0
	for i in range(len(B)):
		if B[i] > 2 * N:
			print(-1)
			res = 1
			break
	if res == 0:
		print(*B)


for i in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = []
	flag = 0
	for j in range(n):
		a.append(b[j])
		k = b[j]
		while k in a or k in b:
			k += 1
		if k > 2 * n:
			print(-1)
			flag = 1
			break
		else:
			a.append(k)
	if flag == 0:
		print(*a)


from functools import reduce
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

def arr():
	return [int(i) for i in input().split()]

def sarr():
	return [int(i) for i in input()]

def inn():
	return int(input())
mo = 1000000007
for _ in range(int(input())):
	n = inn()
	a = arr()
	d = defaultdict(int)
	ans = []
	for i in a:
		d[i] += 1
	for i in range(n):
		res = a[i]
		for j in range(a[i] + 1, 2 * n + 1):
			if j not in d:
				ans += [(res, j)]
				d[j] += 1
				break
	flag = 0
	for i in range(1, 2 * n + 1):
		if i not in d:
			flag = 1
			break
	if flag == 1:
		print(-1)
	else:
		for i in range(n):
			print(ans[i][0], ans[i][1], end=' ')
		print()


import sys, os, io
PI = 3.141592653589793
INF = float('inf')
MOD = 1000000007

def bin32(num):
	return '{0:032b}'.format(num)

def add(x, y):
	return (x + y) % MOD

def sub(x, y):
	return (x - y + MOD) % MOD

def mul(x, y):
	return x * y % MOD

def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)

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

def power(x, y):
	res = 1
	x %= MOD
	while y != 0:
		if y & 1:
			res = mul(res, x)
		y >>= 1
		x = mul(x, x)
	return res

def mod_inv(n):
	return power(n, MOD - 2)

def prob(p, q):
	return mul(p, power(q, MOD - 2))

def ii():
	return int(input())

def li():
	return [int(i) for i in input().split()]

def ls():
	return [i for i in input().split()]
for t in range(ii()):
	n = ii()
	a = li()
	b = [0 for i in range(2 * n)]
	for i in range(n):
		b[2 * i] = a[i]
	inds = [-1 for i in range(2 * n + 1)]
	for i in range(n):
		inds[a[i]] = i
	a.sort()
	a.reverse()
	lol = 1
	for i in a:
		ind = inds[i]
		flag = 0
		for j in range(2 * n, i, -1):
			if inds[j] == -1:
				flag = j
		if flag == 0:
			lol = 0
			break
		b[2 * ind + 1] = flag
		inds[flag] = 2 * ind + 1
	if lol:
		for i in range(n):
			for j in range(i + 1, n):
				if b[2 * i + 1] > b[2 * j] and b[2 * j + 1] > b[2 * i] and (b[2 * i + 1] > b[2 * j + 1]):
					(b[2 * i + 1], b[2 * j + 1]) = (b[2 * j + 1], b[2 * i + 1])
		print(*b)
	else:
		print(-1)


t = int(input())
for _ in range(t):
	n = int(input())
	l = [int(i) for i in input().split(' ')]
	res = []
	a = sorted(list(set([i for i in range(1, 2 * n + 1)]) - set(l)))
	for i in range(n):
		cur = l[i]
		for j in a:
			if j > cur:
				res.append(cur)
				res.append(j)
				a.remove(j)
				break
	if len(res) == n * 2:
		print(' '.join([str(i) for i in res]))
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	se = set()
	flag = True
	li = list(map(int, input().split()))
	for ele in li:
		se.add(ele)
	newli = []
	for ele in li:
		newli.append(ele)
		srch = ele + 1
		if srch > 2 * n:
			flag = False
			break
		while True:
			if srch not in se:
				newli.append(srch)
				se.add(srch)
				break
			else:
				srch += 1
			if srch > 2 * n:
				flag = False
				break
	if flag == False:
		print('-1', end='')
	else:
		for ele in newli:
			print(ele, end=' ')
	print()


t = int(input())
while t:
	t -= 1
	n = int(input())
	b = [int(i) for i in input().split()]
	a = []
	if not 1 in b or 2 * n in b:
		print('-1')
	else:
		disp = []
		for i in range(1, 2 * n + 1):
			if not i in b:
				disp.append([i, True])
		for i in b:
			min = -1
			a.append(i)
			for j in disp:
				if j[1] and j[0] > i:
					min = j[0]
					j[1] = False
					break
			else:
				print(min)
				break
			a.append(min)
		else:
			print(*a)


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	l = [i for i in range(1, 2 * n + 1) if i not in b]
	a = []
	for i in b:
		a.append(i)
		for j in l:
			if j > i:
				a.append(j)
				l.remove(j)
				break
	if len(a) == 2 * n:
		print(*a)
	else:
		print(-1)


for _ in range(int(input())):
	n = int(input())
	l = list(map(int, input().split()))
	h = [0] * (2 * n + 1)
	for i in l:
		h[i] = 1
	sl = []
	i = 0
	mm = 0
	for i in range(n):
		flag = 0
		for j in range(l[i] + 1, 2 * n + 1):
			if h[j] == 0:
				flag = 1
				sl.append(l[i])
				sl.append(j)
				h[j] = 1
				break
		if flag == 0:
			break
	if flag == 0:
		print(-1, end='')
	else:
		for i in range(len(sl)):
			print(sl[i], end=' ')
	print('')


import bisect
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate

def lcm(a, b):
	return a * b // math.gcd(a, b)

def sort_dict(key_value):
	return sorted(key_value.items(), key=lambda kv: (kv[1], kv[0]))

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

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

def string_list():
	return list(input())

def solve():
	n = int(input())
	arr = list_input()
	num = {}
	for i in range(1, 2 * n + 1):
		num[i] = 1
	ans = []
	maxx = 0
	for i in arr:
		maxx = max(maxx, i)
		del num[i]
	if maxx == 2 * n:
		print(-1)
		return
	num = list(num.keys())
	for i in arr:
		ans.append(i)
		temp = bisect.bisect_left(num, i)
		if temp == len(num):
			print(-1)
			return
		ans.append(num[temp])
		num.pop(temp)
	for i in ans:
		print(i, end=' ')
	print()
t = int(input())
for _ in range(t):
	solve()


t = int(input())
while t:
	t -= 1
	n = int(input())
	a = list(map(int, input().split()))
	b = [0] * (2 * n)
	f = set()
	flag = 0
	a1 = a[:]
	for i in range(n):
		if a[i] not in f:
			f.add(a[i])
			b[2 * (i + 1) - 2] = a[i]
		else:
			flag = 1
	a.sort()
	if flag == 1:
		print(-1)
		continue
	c = []
	for i in range(2 * n):
		if i + 1 not in f:
			c.append(i + 1)
	c.sort()
	for i in range(n):
		for j in range(len(c)):
			if c[j] > a1[i]:
				b[2 * (i + 1) - 1] = c[j]
				c.remove(c[j])
				break
	if b.count(0) == 0:
		print(*b)
	else:
		print(-1)


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	b = set(range(1, n * 2 + 1))
	b = b - set(a)
	b = list(b)
	f = 0
	ans = []
	for i in a:
		found = 0
		j = 0
		while j < len(b):
			if b[j] > i:
				found = 1
				break
			j += 1
		if not found:
			f = 1
			break
		else:
			ans.append(i)
			ans.append(b[j])
			del b[j]
	if not f:
		print(*ans)
	else:
		print(-1)


from sys import stdin, stderr

def rl():
	return [int(w) for w in stdin.readline().split()]

def solve(n, b):
	f = [True for i in range(2 * n + 1)]
	for x in b:
		if not f[x]:
			return [-1]
		f[x] = False
	a = []
	for x in b:
		a.append(x)
		for y in range(x + 1, 2 * n + 1):
			if f[y]:
				a.append(y)
				f[y] = False
				break
		else:
			return [-1]
	return a
(t,) = rl()
for _ in range(t):
	print(*solve(rl()[0], rl()))


from bisect import bisect_left

def main():
	for _ in range(int(input())):
		(n, res) = (int(input()), [])
		l = list(map(int, input().split()))
		r = sorted(set(range(1, n * 2 + 1)) - set(l))
		try:
			for a in l:
				res += (a, r.pop(bisect_left(r, a + 1)))
			print(*res)
		except IndexError:
			print(-1)
main()


for _ in range(int(input())):
	n = int(input())
	b = [int(s) for s in input().split()]
	vmax = max(b)
	vmin = min(b)
	a = []
	for i in range(0, n):
		a.append(b[i])
		k = b[i]
		while k in b or k in a:
			k += 1
		if k > 2 * n:
			print(-1)
			break
		a.append(k)
	else:
		print(*a)


t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	tot = [j for j in range(1, n * 2 + 1)]
	rem = [j for j in tot if j not in arr]
	rem = sorted(rem)
	liste = []
	for j in range(n):
		b1 = arr[j]
		flag = False
		for k in range(len(rem)):
			if rem[k] > b1:
				liste.append(b1)
				liste.append(rem[k])
				del rem[k]
				flag = True
				break
		if flag == False:
			print('-1')
			break
	if flag == True:
		print(*liste)


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	n = int(input())
	B = list(map(int, input().split()))
	USE = [0] * (2 * n + 1)
	A = [-1] * (2 * n)
	for i in range(n):
		A[2 * i] = B[i]
		USE[B[i]] = 1
	for i in range(2 * n):
		if A[i] != -1:
			continue
		for j in range(A[i - 1] + 1, 2 * n + 1):
			if USE[j] == 0:
				A[i] = j
				USE[j] = 1
				break
	if -1 in A:
		print(-1)
	else:
		print(*A)


import heapq

def solve(n, t):
	remainingCandidates = sorted(list(set([a for a in range(1, 2 * n + 1)]) - set(t) - set([x for x in range(1, sorted(t)[0], 1)])))
	if len(remainingCandidates) != n:
		return -1
	else:
		used = [False] * len(remainingCandidates)
		ans = []
		for (i, x) in enumerate(t):
			ans.append(x)
			for (j, y) in enumerate(remainingCandidates):
				if y > x and (not used[j]):
					ans.append(y)
					used[j] = True
					break
			if len(ans) % 2 != 0:
				return -1
		return ' '.join((str(x) for x in ans))
for i in range(int(input())):
	n = int(input())
	t = list(map(int, input().split()))
	print(solve(n, t))


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def msi():
	return map(str, input().strip().split(' '))

def li():
	return list(mi())

def dmain():
	sys.setrecursionlimit(1000000)
	threading.stack_size(1024000)
	thread = threading.Thread(target=main)
	thread.start()
import sys
input = sys.stdin.readline
scanner = lambda : int(input())
string = lambda : input().rstrip()
get_list = lambda : list(read())
read = lambda : map(int, input().split())
get_float = lambda : map(float, input().split())

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // math.gcd(a, b)

def is_integer(n):
	return math.ceil(n) == math.floor(n)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	if y == 0:
		return 1
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime

def phi(n):
	result = n
	p = 2
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			result = result * (1.0 - 1.0 / float(p))
		p = p + 1
	if n > 1:
		result = result * (1.0 - 1.0 / float(n))
	return int(result)

def is_prime(n):
	if n == 0:
		return False
	if n == 1:
		return True
	for i in range(2, int(n ** (1 / 2)) + 1):
		if not n % i:
			return False
	return True

def next_prime(n, primes):
	while primes[n] != True:
		n += 1
	return n
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

def factors(n):
	res = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return list(set(res))

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

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()

def binary_search(low, high, w, h, n):
	while low < high:
		mid = low + (high - low) // 2
		if check(mid, w, h, n):
			low = mid + 1
		else:
			high = mid
	return low

def check(val, pair):
	summ = 0
	for x in pair:
		if x[1] > val:
			summ += x[0]
	return summ > val

def sortSecond(val):
	return val[1]
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
alphs = 'abcdefghijklmnopqrstuvwxyz'
from itertools import permutations
import math
import bisect as bis
import random
import sys
import collections as collect
import functools as fnt
from decimal import Decimal

def solve():
	n = scanner()
	b = get_list()
	a = []
	vis = [0] * (2 * n)
	mp = {}
	for x in b:
		mp[x] = 1
		if x > 2 * n:
			print(-1)
			return
		vis[x - 1] = 1
	for x in b:
		a.append(x)
		mp[x] = 1
		for i in range(1, 201):
			if i > x and mp.get(i) == None:
				a.append(i)
				if i > 2 * n:
					print(-1)
					return
				vis[i - 1] = 1
				mp[i] = 1
				break
	if sum(vis) == 2 * n:
		print(*a)
	else:
		print(-1)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
t = scanner()
for i in range(t):
	solve()


class NotFoundError(Exception):

	def __str__(self):
		return 'Lexicograohic sequence nnot found'

def returnNumber(bFinal, a, index):
	for i in range(len(a)):
		if a[i] > bFinal[index] and a[i] not in bFinal:
			return a[i]
	raise NotFoundError()
testCases = int(input())
for t in range(testCases):
	n = int(input())
	b = list(map(int, input().rstrip().split()))
	a = [i for i in range(1, 2 * n + 1)]
	bFinal = [None] * 2 * n
	for i in range(len(b)):
		bFinal[2 * i] = b[i]
	for i in b:
		if i in a:
			a.pop(a.index(i))
	for i in range(n):
		try:
			bFinal[2 * i + 1] = returnNumber(bFinal, a, 2 * i)
		except NotFoundError as e:
			bFinal = -1
			break
	if type(bFinal) is list:
		s = ''
		for m in range(len(bFinal)):
			if m == len(bFinal) - 1:
				s = s + str(bFinal[m])
			else:
				s = s + str(bFinal[m]) + ' '
		print(s)
	else:
		print(-1)


t = int(input())
for i in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = []
	for i in range(1, len(arr) * 2 + 1):
		if i not in arr:
			ans.append(i)
	fina = []
	for i in range(len(arr)):
		fina.append(arr[i])
		for j in range(len(ans)):
			if ans[j] > arr[i]:
				fina.append(ans[j])
				ans.remove(ans[j])
				break
	if len(fina) != 2 * n:
		print(-1)
	else:
		print(*fina, sep=' ')


import math

def main_function():
	test_cases = range(int(input()))
	for test_case in test_cases:
		n = int(input())
		b = [0] + [int(i) for i in input().split(' ')]
		hash_table = [1 for i in range(2 * n + 1)]
		a = [0 for i in range(2 * n + 1)]
		is_good = True
		collector = []
		for i in range(1, n + 1):
			hash_table[b[i]] = 0
			a[i * 2 - 1] = b[i]
		for i in range(1, 2 * n + 1):
			if hash_table[i] == 1:
				collector.append(i)
		for i in range(1, 2 * n + 1):
			if a[i] == 0:
				target = a[i - 1]
				current_index = a[i - 1]
				while current_index <= 2 * n:
					if hash_table[current_index] == 1:
						needed_index = current_index
						hash_table[current_index] = 0
						a[i] = needed_index
						break
					else:
						current_index += 1
				else:
					is_good = False
			if not is_good:
				break
		if is_good:
			print(' '.join([str(i) for i in a[1:]]))
		else:
			print(-1)
main_function()


from collections import Counter as C, defaultdict as D, deque as Q
from operator import itemgetter as I
from itertools import product as P
from bisect import bisect_left as BL, bisect_right as BR
from heapq import heappush as HPUSH, heappop as HPOP
from math import floor as MF, ceil as MC, gcd as MG, factorial as F, sqrt as SQRT, inf as INFINITY, log as LOG
from sys import stdin, stdout
INPUT = stdin.readline
PRINT = stdout.write

def player1():
	print('')

def player2():
	print('')

def isPrime(n):
	for i in range(2, MC(SQRT(n)) + 1):
		if n % i == 0:
			return False
	return True

def factors(x):
	ans = []
	for i in range(1, MC(SQRT(x)) + 1):
		if x % i == 0:
			ans.append(i)
			if x % (x // i) == 0:
				ans.append(x // i)
	return ans

def main():
	for _ in range(int(INPUT())):
		n = int(INPUT())
		b = list(map(int, INPUT().split()))
		c = C(b)
		if c[2 * n]:
			PRINT('%d ' % -1)
			continue
		a = [i for i in range(1, 2 * n + 1) if c[i] == 0]
		ans = []
		l = len(a)
		for v in b:
			index = BR(a, v)
			if index == l:
				ans = -1
				break
			ans.append(a[index])
			a.remove(a[index])
			l -= 1
		else:
			for (x, y) in zip(b, ans):
				PRINT('%d %d ' % (x, y))
			continue
		PRINT('%d ' % -1)
main()


def min_number_after(number: int):
	global other_sequence
	for k in range(len(other_sequence)):
		if other_sequence[k] > number:
			return other_sequence[k]
	return 'No'

def list_subtract():
	global sequence, n
	other_sequence = list(range(1, 2 * n + 1))
	for k in sequence:
		other_sequence.remove(k)
	return other_sequence
t = int(input())
for i in range(t):
	n = int(input())
	sequence = list(map(int, input().split(' ')))
	other_sequence = list_subtract()
	quantity_operations = len(sequence) * 2
	for j in range(0, quantity_operations, 2):
		temp = min_number_after(sequence[j])
		if temp != 'No':
			sequence.insert(j + 1, temp)
			other_sequence.remove(sequence[j + 1])
		else:
			print(-1)
			break
	else:
		sequence = [str(x) for x in sequence]
		print(' '.join(sequence))


from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
from fractions import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = int(1500000.0)
MOD = 10 ** 9 + 7
spf = [i for i in range(MAXN)]
spf[0] = spf[1] = -1

def sieve():
	for i in range(2, MAXN, 2):
		spf[i] = 2
	for i in range(3, int(MAXN ** 0.5) + 1):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def fib(n, m):
	if n == 0:
		return [0, 1]
	else:
		(a, b) = fib(n // 2)
		c = a % m * (b % m * 2 - a % m) % m
		d = a % m * (a % m) % m + b % m * b % m % m
		if n % 2 == 0:
			return [c, d]
		else:
			return [d, c + d]

def charIN(x=' '):
	return sys.stdin.readline().strip().split(x)

def arrIN(x=' '):
	return list(map(int, sys.stdin.readline().strip().split(x)))

def ncr(n, r):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % MOD
		den = den * (i + 1) % MOD
	return num * pow(den, MOD - 2, MOD) % MOD

def flush():
	return sys.stdout.flush()
for _ in range(int(input())):
	n = int(input())
	b = [0] + arrIN()
	a = [0] * (2 * n + 1)
	if 1 not in b or 2 * n in b:
		print(-1)
		continue
	f = [1] * (2 * n + 1)
	for i in range(1, n + 1):
		a[2 * i - 1] = b[i]
		f[b[i]] = 0
	rem = [i for i in range(1, 2 * n + 1) if f[i]]
	rem.sort()
	for i in range(1, n + 1):
		idx = bisect_left(rem, b[i])
		if idx == len(rem):
			print(-1)
			break
		a[2 * i] = rem[idx]
		rem.pop(idx)
	else:
		print(*a[1:])


t = int(input())
for i in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	if 1 not in l:
		print('-1')
	elif 2 * n in l:
		print(-1)
	else:
		new = []
		for i in range(n):
			chc = 1
			new.append(l[i])
			for k in range(l[i], 2 * n + 1):
				if k not in l:
					l.append(k)
					new.append(k)
					chc = 0
					break
			if chc == 1:
				print(-1)
				break
		if chc == 0:
			for i in range(len(new)):
				print(new[i], end=' ')
		print()


import sys
input = sys.stdin.readline
for j in range(int(input())):
	n = int(input())
	b = list(map(int, input().split(' ')))
	save = b.copy()
	temp = set(b)
	c = []
	for k in range(1, 2 * n + 1):
		if k not in temp:
			c.append(k)
	b.sort()
	c.sort()
	ansDict = {}
	ans = 0
	for lol in range(n):
		if b[lol] > c[lol]:
			ans = -1
	for sad in range(n):
		mini = max(c)
		for f in c:
			if f < mini and f > save[sad]:
				mini = f
		ansDict[save[sad]] = mini
		c.remove(mini)
	if ans == -1:
		print(-1)
	else:
		ans = []
		for go in range(n):
			ans.append(str(save[go]))
			ans.append(str(ansDict[save[go]]))
		print(' '.join(ans))


t = int(input())
while t > 0:
	n = int(input())
	C = list(map(int, input().split()))
	A = []
	for i in range(0, n):
		A.append(C[i])
		for j in range(C[i] + 1, 1000):
			if j not in A and j not in C:
				A.append(j)
				break
	D = []
	s = 2 * n
	for i in range(0, s):
		D.append(A[i])
	D.sort()
	a = -1
	for j in range(0, s):
		if D[i] != i + 1:
			a = 0
			break
	if a == 0:
		print('-1')
	else:
		print(*A)
	t = t - 1


t = int(input())
for i in range(t):
	n = int(input())
	ans = []
	l = [int(i) for i in input().split()]
	unl = []
	for i in range(1, 2 * n + 1):
		if i not in l:
			unl.append(i)
	ok = True
	for i in range(2 * n):
		if i % 2 == 0:
			ans.append(l[i // 2])
		else:
			for i in range(len(unl)):
				if unl[i] > ans[-1]:
					ans.append(unl[i])
					unl[i] = 0
					break
			else:
				ok = False
				print(-1)
				break
	if ok == True:
		print(*ans)


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	flag = True
	s = set(b)
	ans = []
	for i in range(n):
		ans.append(b[i])
		k = b[i]
		while k in s:
			k += 1
			if k > n * 2:
				flag = False
				break
		ans.append(k)
		s.add(k)
	if flag:
		print(' '.join(map(str, ans)))
	else:
		print(-1)


t = int(input())
b_all = list()
for i in range(t):
	n = int(input())
	b_str = input().split(' ')
	b_all.append([int(r) for r in b_str])
results = list()
for b in b_all:
	n = len(b)
	used = [False] * (2 * n + 1)
	in_res = [False] * (2 * n + 1)
	bad_seq = False
	for num in b:
		if num > 2 * n:
			bad_seq = True
			break
		used[num] = True
	if bad_seq:
		print('-1')
		continue
	res = []
	for j in b:
		res.append(str(j))
		in_res[j] = True
		try:
			false_index = used.index(False, j)
			res.append(str(false_index))
			in_res[false_index] = True
			used[false_index] = True
		except ValueError:
			res = ['-1']
			break
	print(' '.join(res))


for tin in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	c = [0] * (2 * n + 1)
	for _ in range(len(b)):
		c[b[_]] = 1
	a = [0] * (2 * n)
	v = 0
	for _ in range(n):
		a[v] = b[_]
		x = 0
		for j in range(b[_], 2 * n + 1):
			if c[j] != 1:
				a[v + 1] = j
				c[j] = 1
				x += 1
				break
		if x == 0:
			break
		v += 2
	if v != 2 * n:
		print(-1)
	else:
		for _ in range(2 * n - 1):
			print(a[_], end=' ')
		print(a[-1])


import os
from io import BytesIO, IOBase
import sys
from collections import defaultdict, deque, Counter
from bisect import *
from math import sqrt, pi, ceil
import math
from itertools import permutations
from copy import deepcopy

def main():
	for t in range(int(input())):
		n = int(input())
		b = list(map(int, input().split()))
		f = 0
		c = set(b)
		d = []
		for i in range(1, 2 * n + 1):
			if i not in c:
				d.append(i)
		a = []
		for i in range(n):
			a.append(b[i])
			x = bisect_left(d, b[i])
			if x == len(d):
				f = 1
				break
			a.append(d[x])
			d.remove(d[x])
		if f:
			print(-1)
		else:
			print(*a)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


def solution(n: int, b: list):
	ret = [0] * (2 * n)
	for i in range(n):
		ret[2 * i] = b[i]
		for j in range(b[i] + 1, 2 * n + 1):
			if not j in b:
				ret[2 * i + 1] = j
				b.append(j)
				break
	if 0 in ret:
		print(-1)
		return
	else:
		print(' '.join(map(str, ret)))
t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	solution(n, b)


x = int(input())
for i in range(x):
	a = int(input())
	l = list(map(int, input().split()))
	i = 0
	j = 1
	while i < len(l):
		while 1:
			if l[i] + j not in l:
				l.insert(i + 1, l[i] + j)
				j = 1
				i += 1
				break
			else:
				j += 1
		i += 1
	if max(l) * (max(l) + 1) // 2 != sum(l):
		print(-1)
	else:
		print(*l)


n = int(input())
for i in range(n):
	a_l = int(input())
	l = list(map(int, input().split()))
	temp = [0] * (max(l) * 2 + 1)
	dicti = {}
	flag = False
	for j in range(a_l):
		if l[j] >= a_l * 2:
			flag = True
			break
	if 1 not in l or flag == True:
		print(-1)
	else:
		for j in range(a_l):
			temp[l[j]] = 1
		for j in range(a_l):
			for k in range(l[j] + 1, len(temp)):
				if temp[k] == 0:
					dicti[l[j]] = k
					temp[k] = 1
					break
		sum = 0
		for a in dicti:
			sum += a + dicti[a]
		if sum == a_l * 2 * (a_l * 2 + 1) / 2:
			for j in range(a_l):
				print(l[j], end=' ')
				print(dicti[l[j]], end=' ')
		else:
			print(-1)


for _ in range(int(input())):
	n = int(input())
	ar1 = list(map(int, input().split()))
	ar2 = []
	kek = set()
	for i in range(1, 2 * n + 1):
		if i not in ar1:
			kek.add(i)
	ans = []
	flag = 0
	for i in range(n):
		ans.append(ar1[i])
		num = 2 * n + 1
		for num in range(ar1[i] + 1, 2 * n + 1):
			if num in kek:
				break
		if num < ar1[i] or num not in kek:
			flag = 1
			break
		ans.append(num)
		kek.discard(num)
	if flag == 1:
		print(-1)
	else:
		print(*ans)


import sys
inp = sys.stdin.readline
input = lambda : inp().strip()

def iin():
	return int(input())

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

def main():
	T = iin()
	while T:
		T -= 1
		n = iin()
		a = lin()
		l = 2 * n + 1
		done = [0] * l
		ans = []
		for i in a:
			done[i] = 1
		for i in a:
			ans.append(i)
			for j in range(i + 1, l):
				if done[j] == 0:
					done[j] = 1
					ans.append(j)
					break
			else:
				print(-1)
				break
		else:
			print(*ans)
main()


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	s = set(range(2 * n + 1))
	s.remove(0)
	l = [201] * (2 * n)
	flag = True
	for i in range(0, 2 * n, 2):
		l[i] = b[i // 2]
		s.remove(l[i])
	for i in range(1, 2 * n, 2):
		for num in s:
			if num > l[i - 1] and num < l[i]:
				l[i] = num
		if l[i] == 201:
			print(-1)
			flag = False
			break
		s.remove(l[i])
	if flag:
		print(*l)


I = input
for _ in range(int(I())):
	try:
		n = int(I())
		b = list(map(int, I().split(' ')))
		a = [0 for i in range(2 * n + 1)]
		s = []
		for i in range(n):
			if a[b[i]] == 0:
				a[b[i]] = 1
				s.append(str(b[i]))
				s.append('0')
			else:
				assert 1 == 0
		for i in range(n):
			t = 0
			for j in range(b[i] + 1, 2 * n + 1):
				if a[j] == 0:
					t = j
					a[j] = 1
					break
			if t == 0:
				assert 1 == 0
			s[2 * (i + 1) - 1] = str(t)
		for i in range(1, 2 * n + 1):
			if a[i] == 0:
				assert 1 == 0
		for i in s:
			print(i, end=' ')
		print()
	except AssertionError:
		print('-1')


import sys
input = sys.stdin.readline
from bisect import bisect_right
from sys import stdin, stdout

def main():
	for _ in range(int(input())):
		n = int(input())
		l = [int(s) for s in input().split()]
		tot = set((i + 1 for i in range(2 * n)))
		re = sorted(tot - set(l))
		ans = [-1] * (2 * n)
		flag = 0
		for i in range(n):
			ans[2 * i] = l[i]
			w = bisect_right(re, l[i])
			if w == len(re):
				flag = 1
				break
			ans[2 * i + 1] = re[w]
			re.remove(re[w])
		if flag:
			print(-1)
		else:
			print(*ans)
main()


t = int(input())
while t > 0:
	n = int(input())
	b = [int(x) for x in input().split()]
	a = [0] * (2 * n + 1)
	for i in b:
		a[i] = 1
	s = [0] * (2 * n + 1)
	counter = 1
	failed = False
	for i in b:
		s[counter] = i
		found = False
		for j in range(i + 1, 2 * n + 1):
			if a[j] == 0:
				s[counter + 1] = j
				a[j] = 1
				found = True
				break
		if not found:
			print('-1')
			failed = True
			break
		counter += 2
	if not failed:
		s = s[1:]
		print(' '.join(map(str, s)))
	t -= 1


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = list(map(int, input().split()))[0]
	p = list(map(int, input().split()))
	a = [0] * (2 * n)
	for i in p:
		a[i - 1] = 1
	ans = []
	for i in p:
		j = i
		while j < 2 * n and a[j] != 0:
			j += 1
		if j < 2 * n:
			a[j] = 1
			ans.append(i)
			ans.append(j + 1)
	if len(ans) == 2 * n:
		print(*ans, sep=' ')
	else:
		print(-1)


from collections import defaultdict
for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	mydick = dict()
	mydick = defaultdict(lambda : 0, mydick)
	for i in range(n):
		mydick[b[i]] = 1
	p = 2 * n
	a = []
	ok = True
	if mydick[p] == 1:
		print(-1)
		continue
	for i in range(n):
		a.append(b[i])
		if p - b[i] >= 1:
			j = b[i] + 1
			while j <= p:
				if mydick[j] != 1:
					a.append(j)
					mydick[j] = 1
					break
				j += 1
	if len(a) == p:
		print(*a)
	else:
		print(-1)


for _ in range(int(input())):
	l = int(input())
	arr = [int(h) for h in input().strip().split(' ')]
	newarr = []
	flag = True
	for i in range(2 * l):
		if i % 2 == 0:
			newarr.append(arr[i // 2])
		else:
			num = newarr[-1]
			while num <= 2 * l:
				if num in newarr or num in arr:
					num = num + 1
				else:
					newarr.append(num)
					break
			if newarr[-1] == arr[(i - 1) // 2]:
				print(-1)
				flag = False
				break
	if flag:
		s = ''
		for i in range(len(newarr)):
			s = s + str(newarr[i]) + ' '
		print(s)


import sys
from collections import defaultdict

def make(b):
	n = len(b)
	ans = [-1 for _ in range(2 * n)]
	vis = defaultdict(int)
	for i in range(0, 2 * n, 2):
		ans[i] = b[i // 2]
		vis[b[i // 2]] = 1
	for i in range(1, 2 * n, 2):
		for j in range(ans[i - 1] + 1, 2 * n + 1):
			if vis[j] == 0:
				ans[i] = j
				vis[j] = 1
				break
		if ans[i] == -1:
			return False
	return ans
t = int(sys.stdin.readline())
for _ in range(t):
	n = int(sys.stdin.readline())
	b = list(map(int, sys.stdin.readline().split()))
	a = make(b)
	if a:
		print(*a)
	else:
		print(-1)


from operator import itemgetter
from collections import Counter

def solve(n, b):
	numset = set(range(1, 2 * n))
	sb = set(b)
	if len(sb) != n or not numset >= sb:
		print(-1)
	else:
		used = [0] * (2 * n + 1)
		for bb in b:
			used[bb] = 1
		ans = []
		for bb in b:
			flag = True
			ans.append(bb)
			for i in range(bb + 1, 2 * n + 1):
				if used[i] == 0:
					used[i] = 1
					ans.append(i)
					flag = False
					break
			if flag:
				print(-1)
				return 0
		print(' '.join(map(str, ans)))

def main():
	t = int(input())
	for i in range(t):
		n = int(input())
		b = list(map(int, input().split()))
		solve(n, b)
main()


import sys
from sys import stdin, stdout
import bisect
import math
import heapq

def modinv(n, p):
	return pow(n, p - 2, p)

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

def inin():
	return int(input())
import math

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l

def heapPermutation(a, size, n):
	global x
	if size == 1:
		x.append(a[:])
		return
	for i in range(size):
		heapPermutation(a, size - 1, n)
		if size & 1:
			(a[0], a[size - 1]) = (a[size - 1], a[0])
		else:
			(a[i], a[size - 1]) = (a[size - 1], a[i])
x = []

def main():
	t = inin()
	for _ in range(t):
		n = inin()
		a = ain()
		b = [0] * (2 * n + 1)
		x = []
		for i in a:
			b[i] = 1
		for i in a:
			x.append(i)
			for j in range(i, len(b)):
				if b[j] == 0:
					x.append(j)
					b[j] = 1
					break
		if len(x) == 2 * n:
			print(*x)
		else:
			print(-1)
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def readnumbers(zero=0):
	conv = ord if py2 else lambda x: x
	A = []
	numb = zero
	sign = 1
	i = 0
	s = sys.stdin.buffer.read()
	try:
		while True:
			if s[i] >= b'0'[0]:
				numb = 10 * numb + conv(s[i]) - 48
			elif s[i] == b'-'[0]:
				sign = -1
			elif s[i] != b'\r'[0]:
				A.append(sign * numb)
				numb = zero
				sign = 1
			i += 1
	except:
		pass
	if s and s[-1] >= b'0'[0]:
		A.append(sign * numb)
	return A
main()


testcases = int(input())
masterlist = []
for i in range(testcases):
	input()
	tempseq = list(map(int, input().split(' ')))
	masterlist.append(tuple(tempseq))

def lexicographer(tup):
	buildlist = []
	for i in range(len(tup)):
		val = tup[i]
		buildlist.append(val)
		run = True
		orig = val + 1
		while run == True:
			if orig in buildlist or orig in tup:
				orig += 1
			else:
				buildlist.append(orig)
				run = False
	maxim = max(buildlist)
	for i in range(1, maxim):
		if i not in buildlist:
			return [-1]
	return buildlist
for sequence in masterlist:
	ans = lexicographer(sequence)
	str = ''
	for i in ans:
		str += '{} '.format(i)
	print(str)


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0] * (2 * n)
	used = [False] * (2 * n + 1)
	for i in range(2 * n):
		if i % 2 == 0:
			a[i] = b[i // 2]
			used[a[i]] = True
	poss = True
	for i in range(2 * n):
		if i % 2 == 1:
			for k in range(a[i - 1] + 1, 2 * n + 1):
				if not used[k]:
					a[i] = k
					used[k] = True
					break
			if a[i] == 0:
				poss = False
				break
	if not poss:
		print(-1)
	else:
		print(*a)


t = int(input())
import heapq
for _ in range(t):
	n = int(input())
	B = list(map(int, input().split()))
	if 1 not in set(B):
		print(-1)
		continue
	d = {}
	A = [0] * (2 * n)
	for i in range(n):
		A[2 * i] = B[i]
		d[B[i]] = 2 * i + 1
	flag = True
	ids = []
	heapq.heapify(ids)
	for i in range(1, 2 * n + 1):
		if i in d:
			heapq.heappush(ids, d[i])
		else:
			if not ids:
				flag = False
				break
			id = heapq.heappop(ids)
			if A[id - 1] > i:
				flag = False
				break
			else:
				A[id] = i
	if flag:
		print(*A)
	else:
		print(-1)


t = int(input())
while t:
	t += -1
	n = int(input())
	l = list(map(int, input().split()))
	check = [0] * (2 * n + 1)
	ans = [0] * (2 * n)
	for i in range(0, 2 * n, 2):
		ans[i] = l[i // 2]
		check[ans[i]] = 1
	c = 1
	for i in range(0, 2 * n, 2):
		chintu = 0
		for j in range(ans[i] + 1, 2 * n + 1):
			if check[j] == 0:
				chintu = 1
				check[j] = 1
				ans[i + 1] = j
				break
		if chintu == 0:
			c = 0
			break
	if c == 0:
		print(-1)
	else:
		print(*ans)


t = int(input())
test_cases = [(input(), input()) for i in range(t)]

def solve(test_case):
	n = int(test_case[0])
	b = list(map(int, test_case[1].split()))
	c = [i for i in range(1, 2 * n + 1) if i not in b]
	a = []
	for i in range(n):
		a.append(b[i])
		if c[-1] > b[i]:
			tmp = min([c[j] for j in range(len(c)) if c[j] > b[i]])
			a.append(tmp)
			c.remove(tmp)
		else:
			print(-1)
			return
	print(' '.join(map(str, a)))
for test_case in test_cases:
	solve(test_case)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	n = int(input())
	y = [*map(int, input().split())]
	x = {*range(1, 2 * n + 1)}.difference(y)
	res = []
	for i in y:
		a = [j for j in x if i < j]
		if a:
			b = min(a)
			x.remove(b)
			res.extend([i, b])
		else:
			print(-1)
			break
	if not x:
		print(*res)


import bisect
t = int(input())

def find_gt(a, x):
	i = bisect.bisect_right(a, x)
	if i != len(a):
		return a[i]
	raise ValueError
for _ in range(t):
	b = int(input())
	B = list(map(int, input().split()))
	d = {}
	v = [0]
	x = []
	y = []
	for i in range(1, 2 * b + 1):
		v.append(0)
	for i in B:
		v[i] = 1
	for i in range(1, 2 * b + 1):
		if v[i] == 0:
			y.append(i)
		if v[i]:
			x.append(i)
	i = 0
	f = 1
	while i < b:
		if x[i] < y[i]:
			d[x[i]] = y[i]
		else:
			print(-1)
			f = 0
			break
		i += 1
	if f:
		for i in B:
			s = find_gt(y, i)
			y.remove(s)
			print(i, s, end=' ')
		print()


t = int(input())
for i in range(t):
	n = int(input())
	l = list(map(int, input().split(' ')))
	s = set(l)
	l2 = []
	for j in range(1, 2 * n + 1):
		if j not in s:
			l2.append(j)
	l2.sort()
	done = 0
	for j in range(len(l2)):
		flag = 0
		for k in range(n):
			if isinstance(l[k], int) and l2[j] > l[k]:
				l[k] = [l[k], l2[j]]
				flag = 1
				break
		if flag == 0:
			print(-1)
			done = 1
			break
		flag = 0
	if done == 1:
		done = 0
	else:
		for j in range(len(l)):
			print(min(l[j]), end=' ')
			print(max(l[j]), end=' ')
		print()


t = int(input())
for _ in range(t):
	n = int(input())
	arr = list(map(int, input().split()))
	d = {i: 0 for i in range(1, n * 2 + 1)}
	for i in arr:
		d[i] = 1
	resultset = []
	gflag = True
	for i in arr:
		flag = False
		for j in range(i + 1, n * 2 + 1):
			if d[j] == 0:
				resultset.append(i)
				resultset.append(j)
				d[j] = 1
				flag = True
				break
		if not flag:
			gflag = False
			break
	print(' '.join((str(i) for i in resultset)) if gflag else -1)


t = int(input())
for g in range(0, t):
	n = int(input())
	b = list(map(int, input().split()))
	bnew = []
	bnew.extend(b)
	bnew.sort()
	a = []
	j = 0
	for i in range(1, 2 * n + 1):
		if j < n and i == bnew[j]:
			j = j + 1
		else:
			a.append(i)
	breaks = 0
	for i in range(0, n):
		if bnew[i] < a[i]:
			continue
		else:
			breaks = 1
			break
	if breaks == 1:
		print(-1)
	else:
		for i in range(0, n):
			for j in range(0, len(a)):
				if b[i] < a[j]:
					print(b[i], a[j], end=' ')
					a.remove(a[j])
					break
		print('')


testcase = int(input())
for _ in range(testcase):
	n = int(input())
	arr = [int(num) for num in input().split()]
	deleted = set()
	remaining_nums = set(range(1, 2 * n + 1))
	doable = True
	for num in arr:
		deleted.add(num)
		remaining_nums.remove(num)
	remaining_nums = sorted(list(remaining_nums))
	ans = [0] * (2 * n)
	for (ind1, num1) in enumerate(arr):
		for (ind2, num2) in enumerate(remaining_nums):
			if num2 > num1:
				ans[ind1 * 2] = min(num2, num1)
				ans[ind1 * 2 + 1] = max(num2, num1)
				remaining_nums.pop(ind2)
				break
			if ind2 == len(remaining_nums) - 1:
				doable = False
				break
		if not doable:
			break
	print(' '.join(map(str, ans)) if doable else -1)


t = int(input())
for kk in range(t):
	n = int(input())
	l = list(map(int, input().split()))
	l1 = list(filter(lambda x: x not in l, range(1, n * 2 + 1)))
	l2 = []
	for i in l:
		j = 0
		flag = 0
		while j < len(l1):
			if l1[j] > i:
				l2.append(l1[j])
				flag = 1
				del l1[j]
				break
			j += 1
		if flag == 0:
			break
	if flag == 0:
		print(-1)
	else:
		for i in range(2 * n):
			if i % 2:
				print(l2.pop(0))
			else:
				print(l.pop(0))


t = int(input())
for i in range(t):
	n = int(input())
	lst = [int(j) for j in input().split()]
	a = [0] * 2 * n
	y = True
	for j in range(n):
		a[2 * j] = lst[j]
	for j in range(n):
		x = a[2 * j] + 1
		z = True
		k = 0
		while z == True:
			if x + k not in a:
				a[2 * j + 1] = x + k
				z = False
			k += 1
	for j in range(2 * n):
		if j + 1 not in a:
			y = False
			break
	if y == False:
		print(-1)
	else:
		for j in a:
			print(j, end=' ')


from bisect import *
for t in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	f = 0
	c = set(b)
	d = []
	for i in range(1, 2 * n + 1):
		if i not in c:
			d.append(i)
	a = []
	for i in range(n):
		a.append(b[i])
		x = bisect_left(d, b[i])
		if x == len(d):
			f = 1
			break
		a.append(d[x])
		d.remove(d[x])
	if f:
		print(-1)
	else:
		print(*a)


for _ in range(int(input())):
	n = int(input())
	b = list(map(int, input().split()))
	a = []
	taken = [False] * (2 * n + 1)
	for bi in b:
		taken[bi] = True
	for bi in b:
		a.append(bi)
		next = bi + 1
		while next <= 2 * n and taken[next]:
			next += 1
		if next <= 2 * n:
			a.append(next)
			taken[next] = 1
		else:
			break
	if len(a) == 2 * n:
		print(' '.join(map(str, a)))
	else:
		print(-1)


T = int(input())
for t in range(T):
	N = int(input())
	B = list(map(int, input().split()))
	S = set(B)
	out = []
	for n in range(2 * N):
		if n % 2 == 0:
			out.append(str(B[n // 2]))
		else:
			curr = B[(n - 1) // 2]
			fl = 0
			for i in range(1, N * 2 + 1):
				if i > curr and i not in S:
					out.append(str(i))
					S.add(i)
					fl = 1
					break
			if fl == 0:
				break
	if fl == 0:
		print(-1)
	else:
		print(' '.join(out))


for _ in range(int(input())):
	n = int(input())
	dic = {}
	for i in range(1, 2 * n + 1):
		dic[i] = 0
	arr = list(map(int, input().split()))
	flag = 0
	for i in range(n):
		if arr[i] >= 2 * n:
			flag = 1
		dic[arr[i]] = 1
	l = [0] * (2 * n)
	count = 0
	for i in range(0, 2 * n, 2):
		j = arr[count]
		while j <= 2 * n and dic[j] != 0:
			j += 1
		if j == 2 * n and dic[j] == 1:
			flag = 1
			break
		elif j > 2 * n:
			flag = 1
			break
		l[i] = arr[count]
		count += 1
		l[i + 1] = j
		dic[j] = 1
	if flag == 0:
		print(*l)
	else:
		print(-1)


t = int(input())
for i in range(0, t):
	n = int(input())
	b = []
	c = []
	a = list(map(int, input().split()))
	k1 = 1
	k2 = n * 2
	if k1 in a and k2 not in a:
		for j in range(1, 2 * n + 1):
			if j not in a:
				b.append(j)
		for j in range(0, n):
			k = a[j] + 1
			f = 1
			while k not in b:
				k = k + 1
				if k > 2 * n:
					f = 0
					break
			if f == 0:
				print(-1)
				break
			c.append(a[j])
			c.append(k)
			b.pop(b.index(k))
		if f == 0:
			continue
		for j in range(0, 2 * n):
			print(c[j], end=' ')
		print('')
	else:
		print(-1)


import sys
import math

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]
t = read_int()
for i in range(t):
	n = read_int()
	b = read_int_line()
	l = [i + 1 for i in range(2 * n)]
	for i in b:
		l.remove(i)
	l.sort()
	a = []
	for i in range(n):
		a.append(b[i])
		for j in l:
			if b[i] < j:
				a.append(j)
				l.remove(j)
				break
	if len(a) < 2 * n:
		print(-1)
	else:
		print(*a)


for tc in range(int(input())):
	n = int(input())
	arr = []
	d = {}
	line = input().split()
	for i in range(1, 2 * n + 1):
		d[i] = 1
	for i in range(n):
		arr.append(int(line[i]))
		d[arr[i]] = 0
	b = []
	flag = 0
	for i in range(n):
		ele = arr[i] + 1
		plus = 0
		while ele <= 2 * n:
			plus += 1
			if d[ele] == 1:
				d[ele] = 0
				break
			ele += 1
		if ele > 2 * n:
			flag = 1
			break
		b.append(arr[i] + plus)
	if flag == 1:
		print('-1')
		continue
	i = 0
	while i < n:
		print(arr[i], end=' ')
		print(b[i], end=' ')
		i += 1
	print('')


t = int(input())
for T in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	ans_arr = []
	ans = 0
	for i in range(len(b)):
		if b[i] <= 2 * n:
			ans_arr.append(b[i])
			for j in range(1, 2 * n + 1):
				if b[i] + j not in b and b[i] + j not in ans_arr:
					ans_arr.append(b[i] + j)
					break
		else:
			ans = -1
			break
	for i in range(1, 2 * n):
		if len(ans_arr) != 0 and i not in ans_arr:
			ans = -1
			break
	if ans == -1:
		print(-1)
	else:
		print(*ans_arr)


t = int(input())
for _ in range(t):
	n = int(input())
	used = [0 for i in range(2 * n + 1)]
	a = list(map(int, input().split()))
	for i in range(len(a)):
		used[a[i]] = 1
	ans = []
	is_ok = True
	for i in range(len(a)):
		ans.append(a[i])
		s = False
		for j in range(a[i] + 1, len(used)):
			if used[j] == 0:
				ans.append(j)
				used[j] = 1
				s = True
				break
		if not s:
			is_ok = False
			break
	if not is_ok:
		print(-1)
	else:
		print(' '.join(map(str, ans)))


t = int(input())
res = []
for i in range(t):
	n = input()
	n = int(n)
	b = input().split()
	a = [0] * (2 * n)
	for j in range(n):
		b[j] = int(b[j])
	for j in range(n):
		a[2 * j] = b[j]
	index = 1
	fuck = True
	for j in range(1, 2 * n + 1):
		if not j in a:
			flag = True
			for k in range(n):
				if a[2 * k + 1] == 0 and a[2 * k] < j:
					a[2 * k + 1] = j
					flag = False
					break
			if flag:
				fuck = False
				break
	if fuck:
		res.append(a)
	else:
		res.append([-1])
for i in range(t):
	for j in range(len(res[i])):
		print(res[i][j], end=' ')
	print()


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
cases = int(input())
for t in range(cases):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0] * (2 * n)
	d = {i: True for i in range(1, 2 * n + 1)}
	for i in range(n):
		p = i + 1
		pos = 2 * p - 1
		a[pos - 1] = b[i]
		d[b[i]] = False
	f = 0
	for i in range(n):
		p = i + 1
		pos = 2 * p
		v = b[i] + 1
		while v in d and (not d[v]):
			v += 1
		if v > 2 * n:
			print(-1)
			f = 1
			break
		else:
			d[v] = False
			a[pos - 1] = v
	if f == 0:
		print(*a)


import math
q = int(input())
for _ in range(q):
	n = int(input())
	b = list(map(int, input().split()))
	ans = [0] * (2 * n)
	if min(b) != 1 or max(b) == 2 * n:
		print(-1)
	else:
		l = [1] * (2 * n + 1)
		for i in range(n):
			l[b[i]] = 0
		k = 0
		for i in range(2 * n):
			if i % 2 == 0:
				ans[i] = b[k]
				k += 1
		l[0] = 0
		for i in range(0, 2 * n, 2):
			for j in range(ans[i] + 1, 2 * n + 1):
				if l[j] == 1:
					ans[i + 1] = j
					l[j] = 0
					break
		if ans.count(0) != 0:
			print(-1)
		else:
			print(*ans)


import sys
input = sys.stdin.readline
t = int(input())
import bisect
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	b = [0 for _ in range(2 * n)]
	for x in a:
		b[x - 1] = 1
	c = []
	for i in range(2 * n):
		if b[i] == 0:
			c.append(i + 1)
	try:
		d = []
		for x in a:
			bi = bisect.bisect_left(c, x)
			tmp = c[bi]
			del c[bi]
			d.append(tmp)
		ans = ''
		for i in range(n):
			ans += str(a[i])
			ans += ' '
			ans += str(d[i])
			if i != n - 1:
				ans += ' '
		print(ans)
	except:
		print(-1)


t = int(input())
for l in range(t):
	n = int(input())
	tab = [0 for i in range(2 * n)]
	s = input().split()
	for k in s:
		tab[int(k) - 1] = 1
	num = []
	for i in s:
		j = int(i) - 1
		num.append(j + 1)
		for k in range(j, 2 * n):
			if tab[k] == 0:
				tab[k] = 1
				num.append(k + 1)
				break
	co = tab.count(0)
	if co == 0:
		for m in num:
			print(m, end=' ')
		print()
	else:
		print('-1')


t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	a = [0 for i in range(n + n)]
	vis = [0 for i in range(n + n + 1)]
	for i in range(n):
		a[2 * i] = b[i]
		vis[b[i]] = 1
	ans = 1
	for i in range(n):
		ok = 0
		for j in range(b[i] + 1, n + n + 1):
			if vis[j] == 1:
				continue
			a[2 * i + 1] = j
			vis[j] = 1
			ok = 1
			break
		if ok == 0:
			ans = 0
			break
	if ans == 0:
		print(-1)
	else:
		for i in range(n + n):
			print(a[i], end=' ')
		print()


t = int(input())
while t:
	t -= 1
	n = int(input())
	li = list(map(int, input().split()))
	b_li = [0] * (2 * n)
	for i in range(0, n):
		b_li[i * 2] = li[i]
	have = []
	for i in range(1, 2 * n + 1):
		if i not in li:
			have.append(i)
	for i in range(1, 2 * n + 1, 2):
		pre = b_li[i - 1]
		flag = 0
		for j in range(len(have)):
			if have[j] > pre:
				flag = 1
				break
		if flag == 1:
			b_li[i] = have[j]
			del have[j]
		else:
			print(-1)
			break
	if flag == 1:
		for i in b_li:
			print(i, end=' ')
		print()


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	ansls = [0] * (2 * n)
	used = set(b)
	flag = True
	for i in range(n):
		ansls[2 * i] = b[i]
		for j in range(b[i] + 1, 2 * n + 1):
			if not j in used:
				ansls[2 * i + 1] = j
				used.add(j)
				break
		else:
			flag = False
	if flag:
		print(*ansls)
	else:
		print(-1)


from collections import defaultdict, Counter

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

def main():
	t = int(input())
	for num in range(t):
		n = int(input())
		arr = getlist()
		arr1 = arr.copy()
		box = []
		if min(arr) != 1 or max(arr) >= 2 * n:
			print(-1)
		else:
			for number in arr1:
				box.append(number)
				while number + 1 in arr:
					number += 1
				box.append(number + 1)
				arr.append(number + 1)
			if max(box) > 2 * n:
				print(-1)
			else:
				print(*box)
main()


for _ in range(int(input())):
	N = int(input())
	A = list(map(int, input().split(' ')))
	flag = 0
	maxi = 2 * N
	Ans = []
	mark = {}
	for i in A:
		mark[i] = 1
	for i in A:
		Ans.append(i)
		f = 0
		j = i + 1
		while j <= maxi:
			if mark.get(j, -1) == -1:
				f = 1
				Ans.append(j)
				mark[j] = 1
				break
			j += 1
		if f == 0:
			flag = 1
			break
	if flag == 1:
		print(-1)
	else:
		print(*Ans)


t = int(input())
while t:
	t = t - 1
	n = int(input())
	b = [int(s) for s in input().split()]
	dic = [0] * (2 * n + 1)
	for i in b:
		dic[i] = 1
	x = 2 * n + 1
	a = []
	ans = 1
	for i in b:
		flag = 0
		for j in range(i + 1, x):
			if dic[j] == 0:
				n = j
				dic[j] = 1
				flag = 1
				break
		if flag == 0:
			ans = -1
			break
		else:
			a.append(i)
			a.append(n)
	if ans == 1:
		for i in a:
			print(i, end=' ')
		print()
	else:
		print(ans)


t = int(input())
for tt in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	k = [0] * (2 * n + 1)
	ans = [0] * (2 * n)
	for s in a:
		k[s] = 1
	for r in range(n):
		ans[2 * r] = a[r]
		ss = a[r]
		while ss <= 2 * n and k[ss] == 1:
			ss += 1
		if ss == 2 * n + 1:
			print(-1)
			break
		else:
			ans[2 * r + 1] = ss
			k[ss] = 1
	else:
		print(' '.join(map(str, ans)))


from sys import stdin
input = stdin.readline

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

def it():
	return int(input())
for _ in range(it()):
	n = it()
	l = list(mp())
	v = []
	flag = 0
	for i in range(n):
		v.append(l[i])
		k = l[i]
		while k in v or k in l:
			k += 1
			if k > 2 * n:
				flag = 1
				break
		v.append(k)
	if flag == 0:
		print(*v)
	else:
		print(-1)


def solve():
	n = int(input())
	b = list(map(int, input().split()))
	a = []
	for i in range(n):
		a.append(b[i])
		t = b[i] + 1
		while True:
			if t in a or t in b:
				t = t + 1
			else:
				a.append(t)
				break
	if len(a) == max(a):
		print(*a)
	else:
		print(-1)
for testis in range(int(input())):
	solve()


import atexit
import io
import sys
import math
from collections import defaultdict, Counter
t = int(input())
for i in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	visit = [0] * (2 * n + 1)
	for j in b:
		visit[j] = 1
	l = [2] * n
	flag = 0
	for j in range(n):
		if b[j] + 1 > 2 * n:
			flag = 1
			break
		if visit[b[j] + 1] == 0:
			l[j] = b[j] + 1
			visit[b[j] + 1] = 1
		else:
			p = b[j] + 2
			while p <= 2 * n and visit[p] == 1:
				p += 1
			if p > 2 * n:
				flag = 1
				break
			l[j] = p
			visit[p] = 1
	if visit.count(0) != 1 or flag == 1:
		print(-1)
		continue
	for j in range(n):
		print(b[j], l[j], end=' ')
	print()


def func():
	n_case = int(input())
	for i in range(n_case):
		n = int(input())
		b = list(map(int, input().split()))
		res = {*range(2 * n + 1)} - {*b}
		a = []
		try:
			for i in b:
				minn = min(res - {*range(i)})
				res -= {minn}
				a += (i, minn)
		except:
			a = [-1]
		print(*a)
func()


for t in range(int(input())):
	n = int(input())
	a = list(map(int, input().split()))
	b = [0 for i in range(2 * n)]
	c = [False for i in range(2 * n)]
	i = 0
	j = 0
	while i < 2 * n:
		b[i] = a[j] - 1
		c[a[j] - 1] = True
		i += 2
		j += 1
	(i, k, flag) = (1, 0, 1)
	while i < 2 * n:
		k = b[i - 1]
		flag = 1
		while k < 2 * n:
			if c[k] == False:
				c[k] = True
				flag = 0
				break
			k += 1
		if flag == 0:
			b[i] = k
		else:
			break
		i += 2
	if flag == 1:
		print(-1)
	else:
		for i in range(2 * n):
			print(b[i] + 1, end=' ')
	print()


t = int(input())
for _ in range(t):
	n = int(input())
	b = list(map(int, input().split()))
	for i in range(n):
		b[i] -= 1
	used = [False for _ in range(2 * n)]
	for i in range(n):
		used[b[i]] = True
	ans = [0 for i in range(2 * n)]
	for i in range(n):
		ans[2 * i] = b[i]
	result = True
	for i in range(n):
		found_cand = False
		for cand in range(ans[2 * i] + 1, 2 * n):
			if not used[cand]:
				used[cand] = True
				ans[2 * i + 1] = cand
				found_cand = True
				break
		if not found_cand:
			result = False
	if not result:
		print(-1)
	else:
		print(' '.join([str(item + 1) for item in ans]))


for t in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = [0] * (n * 2)
	for i in range(n):
		ele = arr[i]
		ans[2 * i] = ele
	included = set(arr)
	i = 1
	broken = 0
	while i < 2 * n:
		starting = ans[i - 1]
		ending = 2 * n
		for j in range(starting + 1, ending + 1):
			if j not in included:
				ans[i] = j
				included.add(j)
				break
		if ans[i] == 0:
			broken += 1
			break
		i += 2
	if broken == 0:
		print(*ans)
	else:
		print(-1)


T = int(input())
for i in range(T):
	N = int(input())
	l = [0] * (N * 2 + 1)
	f = 0
	c = 0
	b = [int(x) for x in input().split()]
	for j in range(0, len(b)):
		c = c + 1
		l[c] = b[j]
		c = c + 1
		if b.count(b[j] + 1) == 1 or l.count(b[j] + 1) == 1:
			m = b[j] + 1
			while True:
				m = m + 1
				if b.count(m) == 0 and l.count(m) == 0:
					break
				if m == 2 * N:
					f = 1
					break
			if f == 1:
				break
			else:
				l[c] = m
		else:
			l[c] = b[j] + 1
	for j in range(1, 2 * N + 1):
		if l.count(j) == 0:
			f = 1
			break
	if f == 1:
		print(-1)
	else:
		l.pop(0)
		print(*l)


import bisect
import sys
input = sys.stdin.readline
from collections import defaultdict as dd
t = int(input())
while t:
	n = int(input())
	l = list(map(int, input().split()))
	rem = []
	for i in range(1, 2 * n + 1):
		if i not in l:
			rem.append(i)
	ans = []
	lol = 0
	for i in l:
		ans.append(i)
		ind = bisect.bisect_left(rem, i)
		if ind == len(rem):
			lol = 1
			break
		else:
			ans.append(rem[ind])
			rem.pop(ind)
	if lol:
		print(-1)
	else:
		print(*ans)
	t -= 1


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
import datetime
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def main():
	starttime = datetime.datetime.now()
	if os.path.exists('input.txt'):
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	for _ in range(int(input())):
		n = int(input())
		b = [int(x) for x in input().split()]
		a = [0] * (2 * n)
		d = {}
		for i in b:
			d[i] = 1
		ans = 0
		for i in range(1, n + 1):
			a[2 * i - 2] = b[i - 1]
			t = 0
			for j in range(b[i - 1] + 1, 2 * n + 1):
				if j not in d:
					a[2 * i - 1] = j
					d[a[2 * i - 1]] = 1
					t = 1
					break
			if t == 0:
				ans = -1
				break
		if ans == -1:
			print(ans)
		else:
			print(*a)
	endtime = datetime.datetime.now()
	time = (endtime - starttime).total_seconds() * 1000
	if os.path.exists('input.txt'):
		print('Time:', time, 'ms')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


N = int(input())
for _ in range(N):
	n = int(input())
	b = list(map(int, input().split()))
	a = [-1] * 2 * n
	pos = list(filter(lambda x: x not in b, range(1, 2 * n + 1)))
	f = True
	for (i, el) in enumerate(b):
		a[2 * i] = el
		(st, end) = (0, len(pos))
		new_idx = (st + end) // 2
		idx = None
		min_pos = 2 * n + 1
		while new_idx != idx:
			idx = new_idx
			cur = pos[idx]
			if cur < el:
				st = idx
			else:
				min_pos = min(min_pos, cur)
				end = idx
			new_idx = (st + end) // 2
		try:
			pos.remove(min_pos)
			a[2 * i + 1] = min_pos
		except Exception:
			f = False
			break
	if f:
		print(*a)
	else:
		print(-1)


def Input():
	tem = input().split()
	ans = []
	for it in tem:
		ans.append(int(it))
	return ans
from collections import Counter
T = Input()[0]

def solve(n, b):
	m = 2 * n
	a = []
	for i in range(n):
		a.append([b[i], i])
	a.sort(reverse=True)
	vis = [0 for i in range(m + 1)]
	ans = [0 for i in range(m)]
	for i in range(n):
		vis[a[i][0]] = 1
	for i in range(n):
		flag = False
		big_a = None
		for j in range(m, a[i][0], -1):
			if vis[j] == 0:
				flag = True
				big_a = j
				vis[j] = 1
				break
		if flag:
			ans[2 * a[i][1]] = a[i][0]
			ans[2 * a[i][1] + 1] = big_a
		else:
			return [-1]
	for i in range(1, m, 2):
		for j in range(i + 2, m, 2):
			if ans[j] < ans[i] and ans[j] > ans[i - 1] and (ans[i] > ans[j - 1]):
				(ans[i], ans[j]) = (ans[j], ans[i])
	return ans
for tt in range(T):
	n = Input()[0]
	b = Input()
	ans = solve(n, b)
	if ans[0] == -1:
		print(-1)
	else:
		print(ans[0], end='')
		for i in range(1, 2 * n):
			print('', ans[i], end='')
		print()


from sys import stdin, gettrace
if not gettrace():

	def input():
		return next(stdin)[:-1]

def main():

	def solve():
		n = int(input())
		bb = [int(a) for a in input().split()]
		avail = [False] + [True] * 2 * n
		for b in bb:
			avail[b] = False
		res = []
		for b in bb:
			if b == n * 2:
				print(-1)
				return
			res.append(b)
			c = b + 1
			while not avail[c]:
				c += 1
				if c == 2 * n + 1:
					print(-1)
					return
			res.append(c)
			avail[c] = False
		print(' '.join(map(str, res)))
	q = int(input())
	for _ in range(q):
		solve()
main()


t = int(input())
solutions = []
for i in range(t):
	n = int(input())
	string = str(input())
	st = string.split()
	lst = []
	for j in range(n):
		lst.append(int(st[j]))
	solution = []
	for j in range(n):
		solution.append(lst[j])
		number = lst[j]
		ok = 0
		while ok == 0 and number < 2 * n:
			number = number + 1
			if number not in solution and number not in lst:
				ok = 1
		if ok == 1:
			solution.append(number)
	if len(solution) == 2 * n:
		solutions.append(solution)
	else:
		solutions.append([-1])
for i in range(t):
	for number in solutions[i]:
		print(number, end=' ')
	print()


t = int(input())
from collections import defaultdict
for _ in range(t):
	dic = defaultdict(int)
	dic2 = defaultdict(int)
	n = int(input())
	bl = list(map(int, input().split()))
	for (idx, b) in enumerate(bl):
		dic[b] = idx + 1
	bl_sort = sorted(bl)
	s = 0
	kouho = []
	for b in range(1, 2 * n + 1):
		if not dic[b]:
			if len(kouho) == 0:
				print(-1)
				break
			min_idx = float('inf')
			pos = -1
			for k in kouho:
				if min_idx > dic[k]:
					min_idx = dic[k]
					pos = k
			dic2[pos] = b
			kouho.remove(pos)
		else:
			kouho.append(b)
			s += 1
	else:
		ansl = []
		for b in bl:
			ansl.append(b)
			ansl.append(dic2[b])
		print(*ansl)
	continue


t = int(input())
for _ in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	b = sorted(a)
	used = [0 for i in range(2 * n + 1)]
	flg = 1
	for i in range(n):
		if b[i] > i * 2 + 1:
			print(-1)
			flg = 0
			break
		used[b[i]] = 1
	if flg == 0:
		continue
	ans = []
	for i in range(n):
		ans.append(a[i])
		for j in range(a[i], 2 * n + 1):
			if used[j] == 0:
				ans.append(j)
				used[j] = 1
				break
	print(*ans)


for _ in range(int(input())):
	(n, b) = (int(input()), list(map(int, input().split())))
	d = {e: True for e in range(1, 2 * n + 1)}
	a = [0] * (2 * n)
	for i in range(n):
		a[2 * i] = b[i]
		d[b[i]] = False
	ok = True
	for i in range(1, 2 * n, 2):
		e = a[i - 1] + 1
		while e <= 2 * n:
			if d[e]:
				a[i] = e
				d[e] = False
				break
			e += 1
		if e > 2 * n:
			ok = False
			break
	if not ok:
		print(-1)
	else:
		print(*a)


t = int(input())
s = []
for njj in range(0, t):
	n = int(input())
	b = list(map(int, input().split()))
	if 1 not in b or 2 * n in b:
		s.append([-1])
	else:
		a = []
		for i in b:
			g = 1
			f = i
			while i + g in a or i + g in b:
				g += 1
			if i + g > 2 * n:
				s.append([-1])
				break
			else:
				a.append(f)
				a.append(i + g)
		if len(s) != njj + 1:
			s.append(a)
for i in s:
	for j in i:
		print(j, end=' ')
	print()


for i in range(int(input())):
	n = int(input())
	s = list(map(int, input().split()))
	elems = [0 for i in range(2 * n + 1)]
	ans = []
	for i in range(len(s)):
		elems[s[i]] = 1
	for i in range(len(s)):
		ans.append(s[i])
		ch = s[i] + 1
		while ch <= 2 * n and elems[ch] != 0:
			ch += 1
		if ch > 2 * n:
			ans = -1
			break
		else:
			elems[ch] = 1
			ans.append(ch)
	if ans == -1:
		print(-1)
	else:
		print(*ans)


def helper(helpArr, num):
	for i in range(num, len(helpArr)):
		if helpArr[i] == 0:
			return i + 1
	return -1

def soln(n, arr):
	helpArr = [0] * (2 * n)
	for i in arr:
		helpArr[i - 1] = 1
	ans = []
	for i in arr:
		temp = helper(helpArr, i)
		if temp == -1:
			return -1
		helpArr[temp - 1] = 1
		ans.append(i)
		ans.append(temp)
	return ans
for _ in range(int(input())):
	n = int(input())
	arr = list(map(int, input().split()))
	ans = soln(n, arr)
	if ans == -1:
		print(-1)
	else:
		print(*ans)