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

public class CFA {
  static final PrintWriter out = new PrintWriter(System.out);
  // static final Reader in = new Reader();
  static final Scanner in = new Scanner(System.in);

  static class Reader {
    BufferedReader br;
    StringTokenizer st;

    public Reader() {
      br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
      while (st == null || !st.hasMoreElements()) {
        try {
          st = new StringTokenizer(br.readLine());
        } catch (final 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 (final IOException e) {
        e.printStackTrace();
      }
      return str;
    }
  }

  static long binpow(final int a, final int b) {
    if (b == 0) return 1;
    final long res = binpow(a, b / 2);
    if (b % 2 == 1) return res * res * a; else return res * res;
  }

  static int gcd(final int a, final int b) {
    if (b == 0) return a;
    return gcd(b, a % b);
  }

  static void println(String s){
    System.out.println(s);
  }

  static void print(String s){
    System.out.print(s);
  }


  static int n, k, a[], b[],c[];
  static Map<Integer, Integer> map;
  static char[] w;
  static boolean vis[];

  public static void main(final String[] args) throws Exception {
    int t = in.nextInt();
    while (t-- > 0) {
      n = in.nextInt();
      a = new int[n];
      map = new HashMap<>();

      int mexa = -1,mexb = -1;

      for(int i = 0;i < n;i++){
        a[i] = in.nextInt();
        map.putIfAbsent(a[i],0);
        map.put(a[i],map.get(a[i])+1);
      }
      List<Integer> list = new ArrayList<>(map.keySet());
      Collections.sort(list);

      mexa = mexA();
      mexb = mexB();
      
      // println(" mexa = "+mexa+"  mexb = "+mexb);

      mexa += mexb;
      println(mexa+"");
    }

    out.close();
  }

  static int mexA(){
    for(int i = 0;i < 110;i++){
      
      if(map.get(i) == null)
        return i;
      map.put(i,map.get(i)-1);  
    }
    return -1;

  }

  static int mexB(){
    for(int i = 0;i < 110;i++){
      if(map.get(i) == null || map.get(i) == 0)
        return i;
    }
    return -1;
  }
}
