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.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) {
        FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(System.out);
        Task solver = new Task();
        int t = scan.nextInt();
        for(int tt = 1; tt <= t; tt++) solver.solve(tt, scan, out);
        out.close();
    }

    static class Task {

        public void solve(int testNumber, FastReader scan, PrintWriter out) {
            int n = scan.nextInt();
            Item[] a = new Item[n];
            int[] res = new int[2 * n];
            for(int i = 0; i < n; i++) a[i] = new Item(i, scan.nextInt());
            TreeSet<Integer> have = new TreeSet<>();
            for(int i = 1; i <= 2 * n; i++) have.add(i);
            for(int i = 0; i < n; i++) {
                if(!have.contains(a[i].val)) {
                    out.println(-1);
                    return;
                }
                have.remove(a[i].val);
            }
            Arrays.sort(a);
            for(int i = 0; i < n; i++) {
                Integer next = have.last();
                if(next == null || next < a[i].val) {
                    out.println(-1);
                    return;
                }
                have.remove(next);
                a[i].other = next;
            }
            Arrays.sort(a, new Comparator<Item>() {
                @Override
                public int compare(Item o1, Item o2) {
                    return Integer.compare(o1.index, o2.index);
                }
            });
            for(int k = 0; k < 500; k++) {
                for (int i = n - 1; i >= 0; i--) {
                    for (int j = i + 1; j < n; j++) {
                        if (a[j].other < a[i].other && a[i].other > a[j].val && a[j].other > a[i].val) {
                            int temp = a[i].other;
                            a[i].other = a[j].other;
                            a[j].other = temp;
                        }
                    }
                }
            }
            for(int i = 0; i < n; i++) {
                res[a[i].index * 2] = a[i].val;
                res[a[i].index * 2 + 1] = a[i].other;
            }
            for(int i : res) out.printf("%d ", i);
            out.println();
        }

        static class Item implements Comparable<Item> {
            int index, val;
            int other;

            public Item(int a, int b) {
                index = a;
                val = b;
                other = -1;
            }

            @Override
            public int compareTo(Item o) {
                return Integer.compare(o.val, val);
            }

        }

    }

    static void shuffle(int[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            int temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static void shuffle(long[] a) {
        Random get = new Random();
        for (int i = 0; i < a.length; i++) {
            int r = get.nextInt(a.length);
            long temp = a[i];
            a[i] = a[r];
            a[r] = temp;
        }
    }

    static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public FastReader(String s) throws FileNotFoundException {
            br = new BufferedReader(new FileReader(new File(s)));
        }

        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;
        }
    }

}