Given a set of integers (it can contain equal elements).

You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).

Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example: 

  * mex(\{1,4,0,2,2,1\})=3 
  * mex(\{3,3,2,1,3,0,0\})=4 
  * mex(∅)=0 (mex for empty set) 



The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.

Input

The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.

The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.

The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.

Output

For each test case, print the maximum value of mex(A)+mex(B).

Example

Input


4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6


Output


5
3
4
0

Note

In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.

In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.

In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.

In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
1
100
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
 15
1
0
1
1
2
0 0
2
0 1
2
1 1
2
0 2
2
1 2
3
0 0 0
3
0 1 0
3
0 1 2
4
0 1 2 3
4
1 1 2 3
4
0 1 0 1
4
0 0 0 1
5
0 0 0 0 0

100
 1
0
2
2
0
1
0
2
3
3
4
0
4
3
2

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

public class A670 {
	/*
	 * Yu Lim's OP Template
	 */
	// You got this lmao >:)
	static class Fscan {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		// pass (new FileInputStream("'FILE NAME'.in")) for reading files
		// pass (System.in) for reading standard input
		public Fscan(InputStream stream) {
			this.stream = stream;
		}

		int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		boolean isEndline(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

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

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

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

		String next() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		String nextLine() {
			int c = read();
			while (isEndline(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndline(c));
			return res.toString();
		}

		// returns the next N lines in an integer array
		// each line contains 1 integer
		// delta is how much to add to each input (can be negative)
		// delta is useful if you want to convert 1-based input to 0-based
		int[] nextInts(int N, int delta) {
			int[] ret = new int[N];
			for (int i = 0; i < N; i++)
				ret[i] = nextInt() + delta;
			return ret;
		}

		// returns the next N lines in a long array
		// each line contains 1 long
		// delta is how much to add to each input (can be negative)
		// delta is useful if you want to convert 1-based input to 0-based
		long[] nextLongs(int N, long delta) {
			long[] ret = new long[N];
			for (int i = 0; i < N; i++)
				ret[i] = nextLong() + delta;
			return ret;
		}

		// returns the next N lines in a double array
		// each line contains 1 double
		double[] nextDouble(int N) {
			double[] ret = new double[N];
			for (int i = 0; i < N; i++)
				ret[i] = nextDouble();
			return ret;
		}

		// returns the next N lines in a string array
		// each line contains 1 string
		String[] next(int N) {
			String[] ret = new String[N];
			for (int i = 0; i < N; i++)
				ret[i] = next();
			return ret;
		}

		// returns the next N lines in a string array
		// each line contains 1 string/sentence
		String[] nextLines(int N) {
			String[] ret = new String[N];
			for (int i = 0; i < N; i++)
				ret[i] = nextLine();
			return ret;
		}

		// close the stream (IMPORTANT)
		void close() throws IOException {
			stream.close();
		}
	}/*
		             	^    ^
		              / \  //\
		|\___/|      /   \//  .\
		/O  O  \__  /    //  | \ \
		/     /  \/_/    //   |  \  \
		@___@'    \/_   //    |   \   \ 
		  |       \/_ //     |    \    \ 
		  |        \///      |     \     \ 
		 _|_ /   )  //       |      \     _\
		'/,_ _ _/  ( ; -.    |    _ _\.-~        .-~~~^-.
		,-{        _      `-.|.-~-.           .~         `.
		 '/\      /                 ~-. _ .-~      .-~^-.  \
		    `.   {            }                   /      \  \
		  .----~-.\        \-'                 .~         \  `. \^-.
		 ///.----..>    c   \             _ -~             `.  ^-`   ^-_
		   ///-._ _ _ _ _ _ _}^ - - - - ~                     ~--,   .-~
		                                                         /.-'*/

	// Main/Driver method
	public static void main(String[] args) throws IOException {
		// Fast Scanner and PrintWriter for Standard Input/Output
		Fscan sc = new Fscan(System.in);
		PrintWriter pw = new PrintWriter(System.out);

		int T = sc.nextInt();
		for(; T > 0; T--) {
			int N = sc.nextInt();
			int[] arr = new int[N];
			for(int i = 0; i < N; i++)
				arr[i] = sc.nextInt();
			Arrays.sort(arr);
			boolean[] s1 = new boolean[200];
			boolean[] s2 = new boolean[200];
			for(int i: arr)
				if(s1[i])
					s2[i] = true;
				else
					s1[i] = true;
			int sum = 0;
			for(int i = 0; i < 200; i++)
				if(!s1[i]) {
					sum += i;
					break;
				}
			for(int i = 0; i < 200; i++)
				if(!s2[i]) {
					sum += i;
					break;
				}
			pw.println(sum);
		}
		

		sc.close();
		pw.close();
	}
}
