You are given a sequence b_1, b_2, …, b_n. Find the lexicographically minimal permutation a_1, a_2, …, 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 ≤ t ≤ 100).

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

The second line of each test case consists of n different integers b_1, …, b_n — elements of the sequence b (1 ≤ b_i ≤ 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, …, 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 

import java.awt.Desktop;

import java.io.BufferedReader;


import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.net.URISyntaxException;
import java.sql.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.Vector;



public  class codechef3 {
static class comp implements Comparator<Integer>
{

	@Override
	public int compare(Integer o1, Integer o2) {
		if(Math.abs(o1)>Math.abs(o2))
			return -1;
		else return 1;
	
	}

	
	}
	   

		 static class FastReader
		    {BufferedReader br; 
		        StringTokenizer st; 
		 public FastReader() 
		        {  br = new BufferedReader(new
		                     InputStreamReader(System.in)); 
		        } 
		  
		       String next() 
		        { 
		            while (st == null || !st.hasMoreElements()) 
		            { 
		                try
		                { 
		                    st = new StringTokenizer(br.readLine()); 
		                } 
		                catch (IOException  e) 
		                { 
		                    e.printStackTrace(); 
		                } 
		            } 
		            return st.nextToken(); 
		        } 
		  
		        int nextInt() 
		        { 
		            return Integer.parseInt(next()); 
		        } 
		  
		        long nextLong() 
		        { 
		            return Long.parseLong(next()); 
		        } 
		  
		        double nextDouble() 
		        { 
		            return Double.parseDouble(next()); 
		        } 
		  
		        String nextLine() 
		        { 
		            String str = ""; 
		            try
		            { 
		                str = br.readLine(); 
		            } 
		            catch (IOException e) 
		            { 
		                e.printStackTrace(); 
		            } 
		            return str; 
		        } 
		    } 
		 
		 public static String reverse(String s1)
		 {
			String s2="";
			int n=s1.length();
			for(int i=n-1;i>=0;i--)
			{
				s2+=s1.charAt(i);
			}
			return s2;
			 
			 
		 }
	  

	
		 
		    
		    public static void main(String[] args) 
		    {
		    	FastReader s=new FastReader();
		    	
		    	int t=s.nextInt();
		    	while(t-->0)
		    	{
		    		int n=s.nextInt();
		    	
		    		
		    		ArrayList<Integer> l=new ArrayList<>();
		    		
		    		int max=Integer.MIN_VALUE;
		    		for(int i=0;i<n;i++)
		    		{
		    			int x=s.nextInt();
		    			l.add(x);
		    		}
		    		
		    		ArrayList<Integer> l1=new ArrayList<>();
		    		
		    int flag=0;
		    
		    for(int i=0;i<n;i++)
		    {
		    	int x=l.get(i);
		    	l1.add(x);
		    	x+=1;
		    	while(1>0) {
		    	if(x>2*n)
		    	{
		    		flag=1;
		    		break;
		    	}else
		    	if(!l.contains(x)&&!l1.contains(x))
		    	{	l1.add(x);
		    	break;
		    	}
		    	else x++;
		    	
		    	
		    	}
		    	if(flag==1)
		    		break;
		    	
		    }
		    
		    if(flag==1)
		    	System.out.println("-1");
		    else
		    {
		    	for(int i=0;i<2*n;i++)
		    		System.out.print(l1.get(i)+" ");
		    	System.out.println();
		    }
		    		
		    		
		    		
		    		
		    		
		    }
		    	
		       
		    }
}