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

class Node():
    def __init__(self,val):
        self.val=val
        self.children=None
        self.centroid=None
        self.edges=[]

class Graph():
    def __init__(self):
        self.root=None
    def add_edge(self,a,b):
        if(self.root==None):
            self.root=a
        a.edges.append(b)
        b.edges.append(a)



def dfs_children(g,root,visited):
    visited.add(root.val)
    c=0
    for i in root.edges:
        if(i.val not in visited):
            visited.add(i.val)
            c+=1+dfs_children(g,i,visited)
    root.children=c
    return root.children




def dfs_centroids(g,root,visited,n,ce):
    visited.add(root.val)
    c=-1
    t=0
    for i in root.edges:
        if(i.val not in visited):
            visited.add(i.val)
            c=max(c,i.children+1)
            dfs_centroids(g,i,visited,n,ce)
            t+=i.children+1
    c=max(c,n-t-1)
    root.centroid=c
    if(c in ce):
        ce[c].append(root)
    else:
        ce[c]=[root]
    return root.centroid

def get_leaf(root,li,visited,noti):
    if(root.val==noti.val):
        return False
    visited.add(root.val)
    flag=True
    for i in root.edges:
        if(i.val not in visited and i.val!=noti.val):
            visited.add(i.val)
            li[0]=root
            li[1]=i
            flag=flag & get_leaf(root,li,visited,noti)
    return flag



def process():
    n=int(input())
    li=list(map(int,input().split()))
    counts={}
    for i in li:
        if(i in counts):
            counts[i]+=1
        else:
            counts[i]=1
    ans=-1
    for i in range(0,101):
        if(i in counts):
            if(counts[i]>=2):
                pass
            elif(counts[i]==1 and ans==-1):
                ans=0
                ans+=i
        else:
            if(ans>=0):
                ans+=i
                break
            else:
                ans=2*i
                break
    print(ans)

    # g=Graph()
    # nodes={}
    # for i in range(n-1):
    #     if(a not in nodes):
    #         nodes[a]=Node(a)
    #     if(b not in nodes):
    #         nodes[b]=Node(b)
    #     g.add_edge(nodes[a],nodes[b])
    # visited=set()
    # dfs_children(g,g.root,visited)
    # visited=set()
    # ce={}
    # dfs_centroids(g,g.root,visited,n,ce)
    # centroid=min(list(ce.keys()))
    # if(len(ce[centroid])==1):
    #     print(g.root.val,g.root.edges[0].val)
    #     print(g.root.val, g.root.edges[0].val)
    #     pass
    # else:
    #     li=[-1,ce[centroid][0]]
    #     # print(li[1].val)
    #     for i in ce[centroid][0].edges:
    #         visited={i.val,ce[centroid][0].val}
    #         li[0]=ce[centroid][0]
    #         li[1]=i
    #         if(get_leaf(i,li,visited,ce[centroid][1])):
    #             break
    #
    #     print(li[0].val,li[1].val)
    #     print(li[1].val,ce[centroid][1].val)
    #     a,b=list(map(int,input().split()))




tests=int(input())
for i in range(tests):
    process()