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

 public class Code {

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

//        static int[][] dp = new int[100002][6];
//        static ArrayList<Integer> a=new ArrayList<>();
//            static final int MAX_CHAR = 26;
//        static int c=1;

    public static void main (String[] args) throws java.lang.Exception {
        FastReader sc = new FastReader();
        StringBuffer sb = new StringBuffer();
        ArrayList<Integer> al = new ArrayList<>();
        ArrayList<Integer>as=new ArrayList<>();
       Set<Integer> s=new HashSet<>();
//        Map<Integer, Integer> m = new LinkedHashMap<>();
//        Map<Integer, Integer> mp = new LinkedHashMap<>();


        long t=sc.nextLong();
        while(t-->0)
        {
            int n=sc.nextInt();
            int[] a=new int[n];
            for(int i=0;i<n;i++)
            {
                a[i]=sc.nextInt();
                al.add(i);
                if(!s.contains(a[i]))
                    s.add(a[i]);
                    else
                        as.add(a[i]);
            }
//            Arrays.sort(a);
            int q=solution(a);
//            System.out.println(q);
            s.clear();
            for(int i=0;i<as.size();i++)
                s.add(as.get(i));
            int x=0;
            for(int i=0;i<n;i++)
            {
                if(!s.contains(al.get(i))) {
                     x= al.get(i);
                     break;

                }


            }
            if(q+x>n)
                System.out.println(0);
            else
            System.out.println(q+x);
            al.clear();
            as.clear();
            s.clear();




        }






        }

     static int solution(int[] A)
     {
         int n = A.length;

         // To mark the occurrence of elements
         boolean[] present = new boolean[n + 1];

         // Mark the occurrences
         for (int i = 0; i < n; i++) {

             // Only mark the required elements
             // All non-positive elements and
             // the elements greater n + 1 will never
             // be the answer
             // For example, the array will be {1, 2, 3}
             // in the worst case and the result
             // will be 4 which is n + 1
             if (A[i] > 0 && A[i] <= n)
                 present[A[i]] = true;
         }

         // Find the first element which didn't
         // appear in the original array
         for (int i = 1; i <= n; i++)
             if (!present[i])
                 return i;

         // If the original array was of the
         // type {1, 2, 3} in its sorted form
         return n + 1;
     }



     static long floorSqrt(long x)
     {
         // Base Cases
         if (x == 0 || x == 1)
             return x;

         // Do Binary Search for floor(sqrt(x))
         long start = 1, end = x, ans=0;
         while (start <= end)
         {
             long mid = (start + end) / 2;

             // If x is a perfect square
             if (mid*mid == x)
                 return mid;

             // Since we need floor, we update answer when mid*mid is
             // smaller than x, and move closer to sqrt(x)
             if (mid*mid < x)
             {
                 start = mid + 1;
                 ans = mid;
             }
             else   // If mid*mid is greater than x
                 end = mid-1;
         }
         return ans;
     }









//        private static int walk(int[] a, int k, int z, int i) {
//
//            if (k == 0 || i >= a.length || i < 0) return 0;
//            if (dp[i][z] != 0)
//                return dp[i][z];
//
//
//            int val = a[i] + walk(a, k - 1, z, i + 1);
//            if (i > 0 && z > 0)
//                val = Math.max(val, a[i] + walk(a, k - 1, z - 1, i - 1));
//            dp[i][z] = val;
//            return val;
//
//        }

//    static String sortString(String str) {
//        String k="";
//        // Hash array to keep count of characters.
//        int letters[] = new int[MAX_CHAR];
//
//        // Traverse string and increment
//        // count of characters
//        for (char x : str.toCharArray()) {
//
//            // 'a'-'a' will be 0, 'b'-'a' will be 1,
//            // so for location of character in count
//            // array we will do str[i]-'a'.
//            letters[x - 'a']++;
//        }
//
//        // Traverse the hash array and print
//        // characters
//        for (int i = 0; i < MAX_CHAR; i++) {
//            for (int j = 0; j < letters[i]; j++) {
//
//              k+= (char) (i + 'a');
//            }
//        }
//        return k;
//    }


     static int  countFreq(int arr[], int n)
     {
         Map<Integer, Integer> mp = new HashMap<>();

         // Traverse through array elements and
         // count frequencies
         for (int i = 0; i < n; i++)
         {
             mp.put(arr[i], mp.get(arr[i]) == null ? 1 : mp.get(arr[i]) + 1);
         }

         // To print elements according to first
         // occurrence, traverse array one more time
         // print frequencies of elements and mark
         // frequencies as -1 so that same element
         // is not printed multiple times.
         int sum=0;
         for (int i = 0; i < n; i++)
         {
             if (mp.get(arr[i]) > 1)
             {
                  sum +=mp.get(arr[i]);
                 mp.put(arr[i], -1);
             }
         }
         return sum;
     }
//
//
//
//    ///////////////////////////////////
//    public static String toString(char[] a)
//    {
//        String string = String.valueOf(a);
//
//        return string;
//    }

}
