Problem: Permutation p is a sequence of integers p=[p_1, p_2, ..., p_n], consisting of n distinct (unique) positive integers between 1 and n, inclusive. For example, the following sequences are permutations: [3, 4, 1, 2], [1], [1, 2]. The following sequences are not permutations: [0], [1, 2, 1], [2, 3], [0, 1, 2].

The important key is in the locked box that you need to open. To open the box you need to enter secret code. Secret code is a permutation p of length n. 

You don't know this permutation, you only know the array q of prefix maximums of this permutation. Formally:

  * q_1=p_1, 
  * q_2=max(p_1, p_2), 
  * q_3=max(p_1, p_2,p_3), 
  * ... 
  * q_n=max(p_1, p_2,...,p_n). 



You want to construct any possible suitable permutation (i.e. any such permutation, that calculated q for this permutation is equal to the given array).

Input

The first line contains integer number t (1 ≤ t ≤ 10^4) — the number of test cases in the input. Then t test cases follow.

The first line of a test case contains one integer n (1 ≤ n ≤ 10^{5}) — the number of elements in the secret code permutation p.

The second line of a test case contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n) — elements of the array q for secret permutation. It is guaranteed that q_i ≤ q_{i+1} for all i (1 ≤ i < n).

The sum of all values n over all the test cases in the input doesn't exceed 10^5.

Output

For each test case, print:

  * If it's impossible to find such a permutation p, print "-1" (without quotes). 
  * Otherwise, print n distinct integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n). If there are multiple possible answers, you can print any of them. 

Example

Input


4
5
1 3 4 5 5
4
1 1 3 4
2
2 2
1
1


Output


1 3 4 5 2 
-1
2 1 
1 

Note

In the first test case of the example answer [1,3,4,5,2] is the only possible answer:

  * q_{1} = p_{1} = 1; 
  * q_{2} = max(p_{1}, p_{2}) = 3; 
  * q_{3} = max(p_{1}, p_{2}, p_{3}) = 4; 
  * q_{4} = max(p_{1}, p_{2}, p_{3}, p_{4}) = 5; 
  * q_{5} = max(p_{1}, p_{2}, p_{3}, p_{4}, p_{5}) = 5. 



It can be proved that there are no answers for the second test case of the example.

Solution (in PYTHON3):

Solution:
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 checkPath(source,destination,g):
	visited=[0]*101
	q=Q()
	q.append(source)
	visited[source]=1
	while q:
		node=q.popleft()
		if node==destination:
			return 1
		for v in g[node]:
			if not visited[v]:
				q.append(v)
				visited[v]=1
	return 0
def main():

	for _ in range(int(INPUT())):
		n=int(INPUT());q=list(map(int,INPUT().split( )))


		remaining=sorted([*set([*range(1,n+1)])-set(q)],reverse=True)
		d={}
		ans=[-1]*n
		for i in range(n):
			if q[i] not in d:
				ans[i]=q[i]
			d[q[i]]=1
		for i in range(n):
			if ans[i]==-1:
				ans[i]=remaining.pop()
		valid=[ans[0]]
		for i in range(1,n):
			valid.append(max(ans[i],valid[i-1]))
		if q==valid:
			for v in ans:
				PRINT("%d "%(v))
			PRINT("\n")
		else:
			PRINT("%d\n"%(-1))

main()