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

#include <bits/stdc++.h>
using namespace std;
template <class T>
using PQ = priority_queue<T>;
template <class T>
using PQ_inv = priority_queue<T, vector<T>, greater<T>>;
const double pai = 3.1415926535897;
const long long mod = 1000000007;
const long long INF = 1000000021;
const long long LINF = 2000000000000000000;
const long long MAX = 510000;
const long long MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
  fac[0] = fac[1] = 1;
  finv[0] = finv[1] = 1;
  inv[1] = 1;
  for (long long i = 2; i < MAX; i++) {
    fac[i] = fac[i - 1] * i % MOD;
    inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
    finv[i] = finv[i - 1] * inv[i] % MOD;
  }
}
long long COM(long long n, long long k) {
  if (n < k) return 0;
  if (n < 0 || k < 0) return 0;
  return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long PER(long long n, long long k) {
  if (n < 0 || k < 0) return 0;
  if (n < k) return fac[n];
  return fac[n] * finv[n - k] % mod;
}
long long modinv(long long a, long long m) {
  long long b = m, u = 1, v = 0;
  while (b) {
    long long t = a / b;
    a -= t * b;
    swap(a, b);
    u -= t * v;
    swap(u, v);
  }
  u %= m;
  if (u < 0) u += m;
  return u;
}
long long modpow(long long a, long long n) {
  long long res = 1;
  while (n > 0) {
    if (n & 1) res = res * a % mod;
    a = a * a % mod;
    n >>= 1;
  }
  return res;
}
struct edge {
  long long to, cost;
};
edge m_e(long long xx, long long yy) {
  edge ed;
  ed.to = xx;
  ed.cost = yy;
  return ed;
}
long long b_s(vector<long long>& vec, long long xx) {
  return lower_bound(vec.begin(), vec.end(), xx) - vec.begin();
}
template <class T>
void vecout(vector<T>& vec) {
  for (T t : vec) cout << t << " ";
  cout << "\n";
}
template <class T>
void vecout(vector<vector<T>>& vec) {
  for (vector<T> tvec : vec) {
    for (T t : tvec) cout << t << " ";
    cout << "\n";
  }
}
template <class T>
void vecin(vector<T>& vec) {
  for (long long i = 0; i < (long long)vec.size(); i++) cin >> vec[i];
}
bool chmax(long long& xx, long long yy) {
  if (xx < yy) {
    xx = yy;
    return true;
  }
  return false;
}
bool chmin(long long& xx, long long yy) {
  if (xx > yy) {
    xx = yy;
    return true;
  }
  return false;
}
double dist(long long x, long long y) { return sqrt(x * x + y * y); }
double dist(long long xx1, long long xx2, long long yy1, long long yy2) {
  return sqrt(abs(xx1 - xx2) * abs(xx1 - xx2) +
              abs(yy1 - yy2) * abs(yy1 - yy2));
}
long long mypow(long long nn, long long kk) {
  long long xx = 1;
  for (long long i = 0; i < (long long)(kk); i++) {
    xx *= nn;
  }
  return xx;
}
long long gcd(long long xx, long long yy) {
  long long p = xx;
  long long q = yy;
  if (q > p) swap(p, q);
  while (p % q != 0) {
    p %= q;
    swap(p, q);
  }
  return q;
}
long long lcm(long long xx, long long yy) { return xx * yy / gcd(xx, yy); }
bool prime(long long xx) {
  if (xx <= 1) {
    return 0;
  }
  for (long long i = 2; i * i <= xx; i++) {
    if (xx % i == 0) {
      return 0;
    }
  }
  return 1;
}
signed main() {
  long long t, n, a;
  cin >> t;
  for (long long i = 0; i < (long long)(t); i++) {
    long long ans = 0, d = 2;
    cin >> n;
    map<long long, long long> ma;
    for (long long i = 0; i < (long long)(n); i++) {
      cin >> a;
      if (!ma.count(a)) {
        ma[a] = 1;
      } else {
        ma[a]++;
      }
    }
    long long j = 0;
    while (1) {
      if (!ma.count(j)) {
        break;
      }
      if (ma[j] == 1) {
        d = 1;
      }
      ans += d;
      j++;
    }
    cout << ans << "\n";
  }
}
