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.
#include <bits/stdc++.h>
using namespace std;
void charswap(char* a, char* b) {
  char t = *a;
  *a = *b;
  *b = t;
}
void charbubble(char array[], int n) {
  int i, j;
  bool swapped;
  for (i = 0; i < n - 1; i++) {
    swapped = false;
    for (j = 0; j < n - i - 1; j++) {
      if (array[j] > array[j + 1]) {
        charswap(&array[j], &array[j + 1]);
        swapped = true;
      }
    }
    if (swapped == false) break;
  }
}
void intswap(int* a, int* b) {
  int t = *a;
  *a = *b;
  *b = t;
}
void intbubble(int array[], int n) {
  int i, j;
  bool swapped;
  for (i = 0; i < n - 1; i++) {
    swapped = false;
    for (j = 0; j < n - i - 1; j++) {
      if (array[j] > array[j + 1]) {
        intswap(&array[j], &array[j + 1]);
        swapped = true;
      }
    }
    if (swapped == false) break;
  }
}
void longswap(long long* a, long long* b) {
  long long t = *a;
  *a = *b;
  *b = t;
}
void longbubble(long long array[], long long n) {
  long long i, j;
  bool swapped;
  for (i = 0; i < n - 1; i++) {
    swapped = false;
    {
      for (j = 0; j < n - i - 1; j++) {
        if (array[j] > array[j + 1]) {
          longswap(&array[j], &array[j + 1]);
          swapped = true;
        }
      }
      if (swapped = false) break;
    }
  }
}
void lowercase(char array[], int n) {
  for (int i = 0; i < n; i++) {
    if (array[i] < 97) array[i] = array[i] + 32;
  }
}
bool isprime(long long n) {
  int count = 0;
  int flag = 0;
  for (long long i = n - 1; i > 1; i--) {
    if (n % i == 0) {
      flag++;
    }
  }
  if (flag > 0)
    return false;
  else
    return true;
}
int smallest(int a, int b, int c) {
  return (a < b ? (a < c ? a : c) : (b < c ? b : c));
}
int greatest(int a, int b, int c) {
  return (a > b ? (a > c ? a : c) : (b > c ? b : c));
}
int factorial(int n) {
  if (n == 0)
    return 1;
  else
    return n * factorial(n - 1);
}
void strshiftleft(char array[], int index, int length) {
  int j;
  j = index;
  while (j < length) {
    if (array[j + 1] != '-') {
      array[j] = array[j + 1];
    }
    j++;
  }
}
long long fun(long long n) {
  {
    int i;
    for (i = 3; i <= n; i++) {
      if (n % i == 0)
        break;
      else
        i++;
    }
    return i;
  }
}
long long larger(long long a, long long b) { return (a > b ? a : b); }
long long smallerlong(long long a, long long b) { return (a < b ? a : b); }
int smallerint(int a, int b) { return (a < b ? a : b); }
long long maxfreq(long long array[], long long n) {
  long long maxcount = 0;
  long long max;
  long long i = 0;
  while (i < n - 1) {
    long long count = 1;
    bool flag = true;
    while (flag == true) {
      if (array[i] == array[i + 1]) {
        count++;
        flag = true;
      } else {
        flag = false;
      }
      i++;
    }
    if (count > maxcount) {
      maxcount = count;
      max = array[i - 1];
    }
  }
  return max;
}
int intpartition(int array[], int low, int high) {
  int pivot = array[high];
  int i = low - 1;
  for (int j = low; j <= high - 1; j++) {
    if (array[j] < pivot) {
      i++;
      intswap(&array[i], &array[j]);
    }
  }
  intswap(&array[i + 1], &array[high]);
  return i + 1;
}
void intquick(int array[], int low, int high) {
  if (low < high) {
    int pi = intpartition(array, low, high);
    intquick(array, low, pi - 1);
    intquick(array, pi + 1, high);
  }
}
int counter(int array[], int n, int a) {
  int count = 0;
  for (int i = 0; i < n; i++) {
    if (array[i] == a) count++;
  }
  return count;
}
int main() {
  int t;
  cin >> t;
  for (int i = 1; i <= t; i++) {
    int n;
    cin >> n;
    int array[n];
    for (int j = 0; j < n; j++) {
      cin >> array[j];
    }
    int count[101];
    int mexa, mexb;
    for (int j = 0; j < 101; j++) {
      count[j] = counter(array, n, j);
    }
    for (int j = 0; j < 101; j++) {
      if (count[j] == 0) {
        mexa = j;
        break;
      }
    }
    for (int j = 0; j < 101; j++) {
      if (count[j] <= 1) {
        mexb = j;
        break;
      }
    }
    cout << mexa + mexb << endl;
  }
  return 0;
}
