A permutation of length n is a sequence of integers from 1 to n of length n containing each number exactly once. For example, [1], [4, 3, 5, 1, 2], [3, 2, 1] are permutations, and [1, 1], [0, 1], [2, 2, 1, 4] are not.

There was a permutation p[1 ... n]. It was merged with itself. In other words, let's take two instances of p and insert elements of the second p into the first maintaining relative order of elements. The result is a sequence of the length 2n.

For example, if p=[3, 1, 2] some possible results are: [3, 1, 2, 3, 1, 2], [3, 3, 1, 1, 2, 2], [3, 1, 3, 1, 2, 2]. The following sequences are not possible results of a merging: [1, 3, 2, 1, 2, 3], [3, 1, 2, 3, 2, 1], [3, 3, 1, 2, 2, 1].

For example, if p=[2, 1] the possible results are: [2, 2, 1, 1], [2, 1, 2, 1]. The following sequences are not possible results of a merging: [1, 1, 2, 2], [2, 1, 1, 2], [1, 2, 2, 1].

Your task is to restore the permutation p by the given resulting sequence a. It is guaranteed that the answer exists and is unique.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 400) — the number of test cases. Then t test cases follow.

The first line of the test case contains one integer n (1 ≤ n ≤ 50) — the length of permutation. The second line of the test case contains 2n integers a_1, a_2, ..., a_{2n} (1 ≤ a_i ≤ n), where a_i is the i-th element of a. It is guaranteed that the array a represents the result of merging of some permutation p with the same permutation p.

Output

For each test case, print the answer: n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n), representing the initial permutation. It is guaranteed that the answer exists and is unique.

Example

Input


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


Output


1 2 
1 3 4 2 
1 2 3 4 5 
1 2 3 
2 3 4 1 
import java.io.*;
import java.util.*;

public class Main {

	static class PairComparator implements Comparator<Pair> {
		@Override
		public int compare(Pair x, Pair y) {
			if (x.val < y.val)
				return -1;
			if (x.val > y.val)
				return 1;
			if (x.val == y.val) {
				if (x.ind < y.ind)
					return -1;
				if (x.ind > y.ind)
					return 1;
			}
			return 0;
		}
	}

	static class Pair {
		int ind, val;

		Pair(int i, int v) {
			ind = i;
			val = v;
		}
	}

	static int[] vis;

	static long sum=0;
	static boolean dfs(int curr, List<Integer >[] tree, int minV, int[] p){
		if (p[curr]==-1){
			int minCurr = Integer.MAX_VALUE;
			for (int i=0;i<tree[curr].size();i++){
				minCurr = Math.min(minCurr, p[tree[curr].get(i)]);	
			}
			p[curr] = minCurr;
		}
		if (p[curr]<minV)return false;
		if (p[curr]!=Integer.MAX_VALUE)sum+=p[curr] - minV;
		for (int i=0;i<tree[curr].size();i++){

			if (!dfs(tree[curr].get(i), tree, p[curr]==-1?minV:p[curr], p)){
				return false;
			}	
		}
		return true;

	}
	static long area(int x1,int y1, int x2, int y2){
		return (long)(y2-y1)*(long)(x2-x1);
	}

	static boolean inside(int[] box, int x, int y){
		if (x>=box[0] && x<=box[2] && y>=box[1] && y<=box[3])return true;
		return false;
	}

	static long areaIntersect(int[] box1, int[] box2){
		int[] swap;
		if (box2[0]<box1[0]){
			swap = box1;
			box1 = box2;
			box2 = swap;
		}
		if (box1[1]>=box2[3] || box1[2]<=box2[0] || box1[3]<=box2[1])return 0;
		long v =  area(Math.max(box1[0], box2[0]), Math.max(box1[1], box2[1]),
				Math.min(box1[2], box2[2]), Math.min(box1[3], box2[3]));
		return v;
	}
	
	static long areaIntersect(int[] box1, int[] box2, int[] box3){
		int[] swap;
		boolean swaped=false;
		if (box2[0]<box1[0]){
			swaped=true;
			swap = box1;
			box1 = box2;
			box2 = swap;
		}
		if (box1[1]>=box2[3] || box1[2]<=box2[0] || box1[3]<=box2[1])return 0;
		int[] newBox = {
				Math.max(box1[0], box2[0]), Math.max(box1[1], box2[1]),
				Math.min(box1[2], box2[2]), Math.min(box1[3], box2[3])
		};

		if (swaped){
			swap = box1;
			box1 = box2;
			box2 = swap;	
		}
		box2=box3;
		if (box2[0]<box1[0]){
			swap = box1;
			box1 = box2;
			box2 = swap;
		}
		if (box1[1]>=box2[3] || box1[2]<=box2[0] || box1[3]<=box2[1])return 0;
		int[] newBox2 = {
				Math.max(box1[0], box2[0]), Math.max(box1[1], box2[1]),
				Math.min(box1[2], box2[2]), Math.min(box1[3], box2[3])
		};
		return areaIntersect(newBox, newBox2);

	}

	static void func() throws Exception {
		int n =sc.nextInt();
		int[] arr = sc.intArr(2*n);
		HashSet<Integer > seen = new HashSet<>();
		for (int i=0;i<2*n;i++){
			if (seen.contains(arr[i]))continue;
			seen.add(arr[i]);
			pw.print(arr[i] + " ");
		}
		pw.println();

		
	}

	/*
	 
	 * */
	static PrintWriter pw;
	static MScanner sc;

	public static void main(String[] args) throws Exception {

		pw = new PrintWriter(System.out);
		sc = new MScanner(System.in);

		int tests = 1;
		tests =sc.nextInt(); //comment this line
		while (tests-- > 0) {
			func();
			pw.flush();
		}

	}

	static class MScanner {
		StringTokenizer st;
		BufferedReader br;

		public MScanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}

		public MScanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int[] intArr(int n) throws IOException {
			int[] in = new int[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			return in;
		}

		public long[] longArr(int n) throws IOException {
			long[] in = new long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			return in;
		}

		public int[] intSortedArr(int n) throws IOException {
			int[] in = new int[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			shuffle(in);
			Arrays.sort(in);
			return in;
		}

		public long[] longSortedArr(int n) throws IOException {
			long[] in = new long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			shuffle(in);
			Arrays.sort(in);
			return in;
		}

		public Integer[] IntegerArr(int n) throws IOException {
			Integer[] in = new Integer[n];
			for (int i = 0; i < n; i++)
				in[i] = nextInt();
			return in;
		}

		public Long[] LongArr(int n) throws IOException {
			Long[] in = new Long[n];
			for (int i = 0; i < n; i++)
				in[i] = nextLong();
			return in;
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public char nextChar() throws IOException {
			return next().charAt(0);
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}

	static void shuffle(int[] in) {
		for (int i = 0; i < in.length; i++) {
			int idx = (int) (Math.random() * (i + 1));
			int tmp = in[i];
			in[i] = in[idx];
			in[idx] = tmp;
		}
	}

	static void shuffle(long[] in) {
		for (int i = 0; i < in.length; i++) {
			int idx = (int) (Math.random() * (i + 1));
			long tmp = in[i];
			in[i] = in[idx];
			in[idx] = tmp;
		}
	}
}
