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

/*==============================================
Author      : Shadman Shariar                 ||
Email       : shadman.shariar@northsouth.edu  ||
University  : North South University (NSU)    ||
Facebook    : shadman.shahriar.007            ||
==============================================*/
import java.io.*;
import java.util.*;
//import java.math.BigInteger;
//import java.text.DecimalFormat;
public class Main {
public static Main obj = new Main();
//public static FastReader fr = new FastReader();
//public static Scanner input = new Scanner(System.in);
//public static PrintWriter pw = new PrintWriter(System.out);
//public static DecimalFormat df = new DecimalFormat(".000");
//public static BufferedReader br = new BufferedReader
//(new InputStreamReader(System.in));
public static void main(String[] args) throws Exception {
Scanner input = new Scanner (System.in);
//BigInteger bi1 = new BigInteger("000");
//StringBuilder sb = new StringBuilder();
//StringTokenizer str = new StringTokenizer("String","Split");

//-----------------CODE STARTS FROM HERE------------------//

int tt = input.nextInt();

for (int z = 0; z < tt; z++) {
	int n  =input.nextInt();
	int a[] = new int[101];
	for(int i = 1; i <= n; i++){
		int x = input.nextInt();
		a[x]++;
	}
	int sum = 0;
	for(int i = 1; i <= 2; i++){
		for(int j = 0; j <= 101; j++){
			if(a[j] >= 1) a[j]--;
			else{
				sum += j;
				break;
			}
		}
	} System.out.println(sum);
	

}

//---------------------CODE ENDS HERE---------------------//

        //pw.close();
        input.close();
		System.exit(0);
}

   public static long gcd(long a, long b) {
	   if (a == 0)
		   return b;
	   return gcd(b % a, a);
   }

   public static long lcm(long a, long b) {
	   return (a / gcd(a, b)) * b;
   }

   public static long nCr(long n, long r)
   {
       return factorial(n) / (factorial(r) *
                  factorial(n - r));
   }

   public static long nPr(long n, long r)
   {
    return factorial(n) / factorial(n - r);
   }

   public static int countsubstring(String str)
   {
    int n = str.length();
    return n * (n + 1) / 2;
   }
 
   public static boolean ispalindrome(String str)
   {
    int i = 0, j = str.length() - 1;
    while (i < j) {
        if (str.charAt(i) != str.charAt(j))
            return false;
        i++;
        j--;
    }
    return true;
   }
 
   public static boolean perfectsquare(long x)
   {
    if (x >= 0) {
        long sr = (long)(Math.sqrt(x));
        return ((sr * sr) == x);
    }
    return false;
   }
 
   public static boolean perfectcube(long N)
   {
    int cube; int c = 0;
    for (int i = 0; i <= N; i++) {
        cube = i * i * i;
        if (cube == N) {
           
            c=1; break;
        }
        else if (cube > N) {
          
           c=0 ; break ;
        }
    }
	  if (c==1)return true;
	  else return false;
   }
 
  public static int divcount(int n)
   {
       boolean hash[] = new boolean[n + 1];
       Arrays.fill(hash, true);
       for (int p = 2; p * p < n; p++)
           if (hash[p] == true)
               for (int i = p * 2; i < n; i += p)
                   hash[i] = false;
       int total = 1;
       for (int p = 2; p <= n; p++) 
       {
           if (hash[p])
           {
               int count = 0;
               if (n % p == 0) 
               {
                   while (n % p == 0) 
                   {
                       n = n / p;
                       count++;
                   }
                   total = total * (count + 1);
               }
           }
       }
       return total;
   }
   
 public static void printdiv(int n)
  {
      for (int i=1; i<=Math.sqrt(n); i++)
      {
          if (n%i==0)
          {
              if (n/i == i)
                  System.out.print(" "+ i);
    
              else
                  System.out.print(i+" " + n/i + " " );
          }
      }
  }
  
   public static boolean[] sieveOfEratosthenes(int n)
   {
    boolean prime[] = new boolean[n + 1];
    for (int i = 0; i <= n; i++)
        prime[i] = true;
 
    for (int p = 2; p * p <= n; p++)
    {
        if (prime[p] == true)
        {
            for (int i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
    prime[1]=false;
    return prime;
   }
	
   public static int removeduplicateelements(int arr[], int n){ 
		Arrays.sort(arr);
        if (n==0 || n==1){  
            return n;  
        }  
        int[] temp = new int[n];  
        int j = 0;  
        for (int i=0; i<n-1; i++){  
            if (arr[i] != arr[i+1]){  
                temp[j++] = arr[i];  
            }  
         }  
        temp[j++] = arr[n-1];      
        for (int i=0; i<j; i++){  
            arr[i] = temp[i];  
        }  
        return j;  
    }  
	
	public static int fibon(int n) {
 
		if (n <= 1) {
 
			return n;
		}
		int[] array = new int[n + 1];
		array[0] = 0;
		array[1] = 1;
		for (int i = 2; i <= n; i++) {
			array[i] = array[i - 2] + array[i - 1];
		}
 
		return array[n];
 
	}
 
	public static long sumofdigits(long n) {
		long sum = 0;
 
		while (n != 0) {
			sum = sum + n % 10;
			n = n / 10;
		}
 
		return sum;
	}
 
	public static int reversedigits(int num) {
		int rev_num = 0;
		while (num > 0) {
			rev_num = rev_num * 10 + num % 10;
			num = num / 10;
		}
		return rev_num;
	}
 
	public static int binarysearch(int arr[], int l, int r, int x) {
 
		if (r >= l) {
			int mid = l + (r - l) / 2;
			if (arr[mid] == x)
				return mid;
			if (arr[mid] > x)
				return binarysearch(arr, l, mid - 1, x);
			return binarysearch(arr, mid + 1, r, x);
		}
		return -1;
	}

	public static void rangeofprimenumber(int a, int b) {
		int i, j, flag;
		for (i = a; i <= b; i++) {
			if (i == 1 || i == 0)
				continue;
			flag = 1;
			for (j = 2; j <= i / 2; ++j) {
				if (i % j == 0) {
					flag = 0;
					break;
				}
			}
			if (flag == 1)
				System.out.println(i);
		}
	}
 
	public static boolean isprime(long n) {
		if (n <= 1)
			return false;
		else if (n == 2)
			return true;
		else if (n % 2 == 0)
			return false;
		for (long i = 3; i <= Math.sqrt(n); i += 2) {
			if (n % i == 0)
				return false;
		}
		return true;
	}
 
	public static long factorial(long n) {
		return (n == 1 || n == 0) ? 1 : n * factorial(n - 1);
	}
 
	public static int[] reversearrayinrange(int arr[], int start, int end) {
		int temp;
 
		while (start < end) {
			temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
			start++;
			end--;
		}
	  return arr;
	}
 
    public 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;
		}
	}
}