Problem: A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.

Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule: 

  * q_i = max(p_1, p_2, …, p_i). 



Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.

An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].

For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially: 

  * [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation); 
  * [3, 1, 4, 2, 7, 6, 5]; 
  * [3, 2, 4, 1, 7, 5, 6]; 
  * [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation). 



For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.

Input

The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.

The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).

The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).

It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.

It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.

Output

For each test case, output two lines: 

  * on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp; 
  * on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp; 

Example

Input


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


Output


3 1 4 2 7 5 6 
3 2 4 1 7 6 5 
1 2 3 4 
1 2 3 4 
3 4 5 1 2 7 6 
3 4 5 2 1 7 6 
1 
1 

Solution (in JAVA):

Solution:

import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.Math.PI;
import static java.lang.Math.min;
import static java.lang.System.arraycopy;
import static java.lang.System.exit;
import static java.util.Arrays.copyOf;

import java.util.LinkedList;
import java.io.FileReader;
import java.io.FileWriter;
import java.math.BigInteger; 
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.NoSuchElementException;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.StringTokenizer;
import java.util.Comparator;
import java.lang.StringBuilder;
import java.util.Collections;
public class Solution {

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	static long scanLong() throws IOException {
		return parseLong(scanString());
	}
	static double scanDouble() throws IOException {
		return parseDouble(scanString());
	}

	static String scanString() throws IOException {
		if (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}
	static String scanLine() throws IOException {
		return in.readLine();
	}


	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;
	

	public static void main(String[] args) {
		try {
			long startTime = System.currentTimeMillis();

			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			//in = new BufferedReader(new FileReader("input.txt"));
			//out = new PrintWriter(new FileWriter("output.txt"));
			
			
			solve();
			
			long endTime   = System.currentTimeMillis();
			long totalTime = endTime - startTime;
			//System.out.println(totalTime+"  "+System.currentTimeMillis() );
			in.close();
			out.close();
			
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
	private static void solve() throws IOException{
		int test=scanInt(); 
		
		
		while(--test>-1){
			ArrayList<Integer> min=new ArrayList<>();
			ArrayList<Integer> max=new ArrayList<>();
			ArrayList<Integer> notPresentX=new ArrayList<>();
			ArrayList<Integer> notPresentY=new ArrayList<>();
			int n=scanInt();
			int arr[]=new int[n];
			boolean values[]=new boolean[n+1];
			int left=-1,right=-1;
			for(int i=0; i<n; ++i){
				arr[i]=scanInt();
				values[arr[i]]=true;
			}
			for(int i=1; i<=n; ++i){
				if(!values[i]){
					notPresentX.add(i);
					notPresentY.add(i);
				}
			}
			min.add(arr[0]);
			max.add(arr[0]);
			int x=0;
			for(int i=1; i<n;++i){
				if(arr[i-1]<arr[i]){
					min.add(arr[i]);
					max.add(arr[i]);
				}
				else{
					min.add(notPresentX.get(x++));
					max.add(getMax(arr[i],notPresentY));
				}
			}
			display(min);
			display(max);
		}
		
	}
	private static void display(ArrayList<Integer> arr){
		for(int i=0; i<arr.size(); ++i)
				out.print(arr.get(i)+" ");
			out.println();
	}
	private static int getMax(int val, ArrayList<Integer> notPresent){
		int lv=0, uv=notPresent.size()-1; int idx=-1;
		while(lv<=uv){
			int mid=lv+(uv-lv)/2;
			if(notPresent.get(mid)>val){
				uv=mid-1;
			}
			else{
				idx=mid;
				lv=mid+1;
			}
		}
		int ans=notPresent.get(idx);
		notPresent.remove(idx);
		return ans;
	}
	
 }