Problem: 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 

Solution (in JAVA):

Solution:

import java.util.*;
import java.lang.*;
import java.io.*;


public class Main {

    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 void readArray(FastReader scan, int[] a, int N) {
        for(int i = 0; i < N; i++) {
            a[i] = scan.nextInt();
        }
    }

    public static void main(String[] args) {
        D();
    }

    public static void A() {
        FastReader scan = new FastReader();
        int T = scan.nextInt();
        while(T-- > 0) {
            int a = scan.nextInt();
            int b = scan.nextInt();
            int x = scan.nextInt();
            int y = scan.nextInt();
            int ans1 = Math.max((a - x - 1) * b, x * b);
            int ans2 = Math.max((b - y - 1) * a, y * a);
            System.out.println(Math.max(ans1, ans2));
        }
    }

    public static void D() {
        FastReader scan = new FastReader();
        int T = scan.nextInt();
        while(T-- > 0) {
            int N = scan.nextInt();
            int[] b = new int[N];
            readArray(scan, b, N);
            int[] a = new int[2 * N];
            int[] n = new int[2 * N];
            for(int i = 0; i < 2 * N; i += 2) {
                a[i] = b[i/2];
                n[a[i] - 1]++;
            }
            int k = -1;
            for(int i = 1; i < 2 * N; i += 2) {
                k = a[i - 1];
                if(k == 2 * N) {
                    System.out.println(-1);
                    break;
                }
                while(n[k] != 0) {
                    k++;
                    if(k == 2 * N) {
                        break;
                    }
                }
                if(k == 2 * N) {
                    System.out.println(-1);
                    break;
                }
                n[k] = 1;
                a[i] = k + 1;
            }
            if(k == 2 * N) {
                continue;
            }
            StringBuilder output = new StringBuilder();
            for(int i = 0; i < 2 * N; i++) {
                output.append(a[i]).append(' ');
            }
            System.out.println(output);
        }
    }
}