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.
######################################################
############Created by Devesh Kumar###################
#############devesh1102@gmail.com####################
##########For CodeForces(Devesh1102)#################
#####################2020#############################
######################################################
import sys
input = sys.stdin.readline
 
import sys 
import heapq 
import copy
import math
import decimal
 
# import sys.stdout.flush as flush
# from decimal import *
#heapq.heapify(li) 
#
#heapq.heappush(li,4) 
#
#heapq.heappop(li)
#
# &    Bitwise AND Operator    10 & 7 = 2
# |    Bitwise OR Operator    10 | 7 = 15
# ^    Bitwise XOR Operator    10 ^ 7 = 13
 
# <<    Bitwise Left Shift operator    10<<2 = 40
# >>    Bitwise Right Shift Operator
# '''############ ---- Input Functions ---- #######Start#####'''
# n = 100
# parent = [-1 for i in range(n)]
# def find(a):
#     if parent[a] == a:
#         return a
#     else:
#         parent[a] = find(parent[a])
    
# def union(a,b):








    # print(lsp )
def inp():
    return(int(input()))
def inlt(): 
    return(list(map(int,input().split())))
def insr():
    s = input()
    return(list(s[:len(s) - 1]))
def insr2():
    s = input()
    s = list(s[:len(s) - 1])
    s = [ord(s[i]) - ord("a") for i in range(len(s))]
    return s
def invr():
    return(map(int,input().split()))
############ ---- Input Functions ---- #######End
# #####   


ans = 0
def pr_list(a):
    print( *a , sep=" ")

def swap(a,b):
    temp = a
    a = b
    b = temp
    return [ a,b]
    # return [b,a]
def pri(a,b):
    s = "? " + str(a) + " " + str(b)
    print(s)
    sys.stdout.flush()
def main():
    tests =  inp()
    # tests = 1
    mod = 1000000007
    limit = 10**18
    ans = 0
    stack = []
    hashm = {}
    arr = []
    heapq.heapify(arr) 
    def find_next(hashm,itr):
        for i in range(itr,len(hashm)):
            if hashm[i] == 0:
                return i 

    for test in range(tests):
        n= inp()
        arr= inlt()
        hashm = [0 for i in range(103)]

        for i in arr:
            hashm[i] = hashm[i]+1
        ans = 0
        found = 0
        for i in range(101):
            if hashm[i] == 0:
                if found == 1:
                    ans = ans + i
                    found= 2
                    break
                else:
                    found= 2
                    ans= ans + 2*i
                    break
            elif hashm[i] == 1:
                if found == 1:
                    found = 2
                    ans = ans + i
                    break
                elif found== 0:
                    found = 1
                    ans= ans + i
                    ans = ans + find_next(hashm,i+1)
                    break 
        print(ans)



            
                

        


if __name__== "__main__":
    main()
