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

//note: 0<=|int|<=2 * 10^9
//note: 0<=|long|<= 9 * 10^18
//note: 20! max w/ long
//note: 91st fibonacci # highest calculable w/long
//note: 0 <= |double| <= 1.8 * 10^308
//note: 170! max w/long;
//java machine can make 10^8 computations in a second.
import java.io.*;
import java.util.*;
import java.math.BigInteger;
    
public class CP{
    private static int MAX = Integer.MAX_VALUE;
    private static int MIN = Integer.MIN_VALUE;
    private static int[][] dirs = new int[][] {{-1,0},{0,1},{1,0},{0,-1}};
    public static void main(String[] args) throws IOException{
        FastScanner sc = new FastScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        
        int t = sc.nextint();
        while(t-- > 0) {
        	int n = sc.nextint();
        	int[] nums = sc.read(n);
        	Map<Integer, Integer> mp = new HashMap<>();
        	for(int i = 0; i < n; i++) {
        		mp.put(nums[i], mp.getOrDefault(nums[i], 0)+1);
        	}
        	int ans = 0;
        	int left = 0;
        	int right = 0;
        	int count = 0;
        	boolean ok = true;
        	for(int i = 0; i <= 100; i++) {
        		if(mp.containsKey(i)) {
        			if(mp.get(i) >= 1) {
        				++left;
            		}
        			if(ok && mp.get(i) >= 2) {
        				++right;
        			}
        			else {
        				ok = false;
        			}
        		}
        		else {
        			break;
        		}
        	}
        	out.println(left+right);
        }
        
        
        out.close(); 
    }
    
    private static class Point{
        int x, y;
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
    
    private static class Edge{
        Point start, end;
        int weight;
        public Edge(Point start, Point end, int weight) {
            this.start = start;
            this.end = end;
            this.weight = weight;
        }
    }
    
    private static class Node{
        Set<Node> adj = new HashSet<>();
        
        public void add(Node n) {
            adj.add(n);
        }
    }
    
    private static class UnionFind{
        int numComponents;
        int[] component;
        public UnionFind(int n) {
            numComponents = n;
            component = new int[n];
        }
        
        public void unite(int n1, int n2) {
            if(findComponent(n1) != findComponent(n2)) {
                component[findComponent(n1)] = n2;
                numComponents--;
            }
        }
        
        public int findComponent(int n) {
            if(component[n] != n) {
                component[n] = findComponent(component[n]);
            }
            return component[n];
        }
    }
   
    private static class FenTree{
        private long[] tree;
        public FenTree(int size) {
            tree = new long[size+1];
        }
        
        public void add(int index, int add) {
            while(index < tree.length) {
                tree[index] += add;
                index += (index & -index);
            }
        }
        
        public long sum(int index) {
            long sum = 0;
            while(index > 0) {
                sum += tree[index];
                index -= (index & -index);
            }
            
            return sum;
        }
    }
    
    private static long modInverse(long a, long b) {
        long bb = b, temp, q;
        long x0 = 0, x1 = 1;
        if(b == 1){
            return 1L;
        }
        while(a > 1){
            q = a/b;
            temp = b; b = a%b; a=temp;
            temp = x0; x0 = x1-q*x0; x1 = temp;
        }
        if(x1 < 0){
            x1 += bb;
        }
        return x1;
    }
    private static long gcd(long a, long b) {
        if(a == 0) {
            return b;
        }
        return gcd(b%a, a);
    }
    
    private static int gcd(int a, int b){
        if(a == 0){
            return b;
        }
        return gcd(b%a, a);
    }

    static final Random random = new Random();
    
    static void sort(int[] a) {
        int n = a.length;
        for(int i = 0; i< n; i++) {
            int r = random.nextInt(n), temp=a[r];
            a[r] = a[i]; a[i] = temp;
        }
        Arrays.sort(a);
    }
    
    private static PrintWriter out;
    private static BufferedReader br;
    private static StringTokenizer st;
    
    private static class FastScanner{
        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        
        String next() {
            while(st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        
        int[] read(int n) {
            int[] res = new int[n];
            for(int i = 0; i < n; i++) {
                res[i] = nextint();
            }
            return res;
        }
        
        int nextint() {
            return Integer.parseInt(next());
        }
        
        double nextdouble() {
            return Double.parseDouble(next());
        }
        
        long nextlong() {
            return Long.parseLong(next());
        }
        
        String nextline() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        
    }
    
}