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 PrintJam(int tc, int val) {
  cout << "Case #" << tc + 1 << ": " << val << '\n';
}
void PrintJam(int tc, const string& val) {
  cout << "Case #" << tc + 1 << ": " << val << '\n';
}
template <typename T>
void PrintJam(int tc, const vector<T>& val) {
  cout << "Case #" << tc + 1 << ": ";
  for (int i = 0; i < val.size(); ++i) {
    cout << val[i] << ' ';
  }
  cout << '\n';
}
template <typename T = int>
vector<T> ReadVector(int sz) {
  vector<T> v(sz);
  for (int i = 0; i < sz; ++i) cin >> v[i];
  return v;
}
template <typename Cont>
bool IsUnique(int sz, const Cont& a) {
  vector<bool> used(sz, false);
  for (auto el : a) {
    if (used[el]) return false;
    used[el] = true;
  }
  return true;
}
int64_t BinPow(int64_t a, int64_t p) {
  if (p == 0) return 1;
  if (p == 1) return a;
  if (p % 2 == 0) {
    auto r = BinPow(a, p / 2);
    return r * r;
  } else {
    auto r = BinPow(a, p - 1);
    return r * a;
  }
}
template <typename Predicate>
int bin(int from, int to, Predicate predicate) {
  while (from + 1 < to) {
    int m = from + (to - from) / 2;
    if (predicate(m))
      from = m + 1;
    else
      to = m;
  }
  return from;
}
vector<vector<int>> ReadGraph(int n, int m, bool orient = false,
                              bool minus_one = true) {
  vector<vector<int>> g(n);
  for (int i = 0; i < m; ++i) {
    int a, b;
    cin >> a >> b;
    g[a - minus_one].push_back(b - minus_one);
    if (!orient) g[b - minus_one].push_back(a - minus_one);
  }
  return g;
}
struct DSU {
  explicit DSU(int n) : parent(n), pts(n, 0) {
    iota(parent.begin(), parent.end(), 0);
  }
  void Union(int a, int b) {
    a = Get(a);
    b = Get(b);
    if (a == b) return;
    if (pts[a] < pts[b]) swap(a, b);
    parent[b] = a;
    pts[b] -= pts[a];
  }
  int Get(int x) {
    while (x != parent[x]) x = parent[x];
    return x;
  }
  void Add(int x, int v) { pts[Get(x)] += v; }
  int GetPts(int x) const {
    int ans = pts[x];
    while (x != parent[x]) {
      x = parent[x];
      ans += pts[x];
    }
    return ans;
  }
  vector<int> parent, pts;
};
using ll = int64_t;
int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);
  int t;
  cin >> t;
  for (int _ = 0; _ < t; ++_) {
    int n;
    cin >> n;
    auto a = ReadVector(n);
    vector<int> cnt(101, 0);
    for (auto el : a) cnt[el]++;
    int ans = 0;
    int i = 0;
    while (i <= 100 && cnt[i] > 0) {
      --cnt[i];
      ++i;
    }
    ans += i;
    i = 0;
    while (i <= 100 && cnt[i] > 0) {
      --cnt[i];
      ++i;
    }
    ans += i;
    cout << ans << '\n';
  }
  return 0;
}
