Let's denote a k-step ladder as the following structure: exactly k + 2 wooden planks, of which

  * two planks of length at least k+1 — the base of the ladder; 
  * k planks of length at least 1 — the steps of the ladder; 



Note that neither the base planks, nor the steps planks are required to be equal.

For example, ladders 1 and 3 are correct 2-step ladders and ladder 2 is a correct 1-step ladder. On the first picture the lengths of planks are [3, 3] for the base and [1] for the step. On the second picture lengths are [3, 3] for the base and [2] for the step. On the third picture lengths are [3, 4] for the base and [2, 3] for the steps. 

<image>

You have n planks. The length of the i-th planks is a_i. You don't have a saw, so you can't cut the planks you have. Though you have a hammer and nails, so you can assemble the improvised "ladder" from the planks.

The question is: what is the maximum number k such that you can choose some subset of the given planks and assemble a k-step ladder using them?

Input

The first line contains a single integer T (1 ≤ T ≤ 100) — the number of queries. The queries are independent.

Each query consists of two lines. The first line contains a single integer n (2 ≤ n ≤ 10^5) — the number of planks you have.

The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^5) — the lengths of the corresponding planks.

It's guaranteed that the total number of planks from all queries doesn't exceed 10^5.

Output

Print T integers — one per query. The i-th integer is the maximum number k, such that you can choose some subset of the planks given in the i-th query and assemble a k-step ladder using them.

Print 0 if you can't make even 1-step ladder from the given set of planks.

Example

Input


4
4
1 3 1 3
3
3 3 2
5
2 3 3 4 2
3
1 1 2


Output


2
1
2
0

Note

Examples for the queries 1-3 are shown at the image in the legend section.

The Russian meme to express the quality of the ladders:

<image>
#
# Yet I'm feeling like
# 	There is no better place than right by your side
# 		I had a little taste
# 			And I'll only spoil the party anyway
# 				'Cause all the girls are looking fine
# 					But you're the only one on my mind


import sys
inf = float("inf")
#sys.setrecursionlimit(1000000)


# abc='abcdefghijklmnopqrstuvwxyz'
# abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod,MOD=1000000007,998244353
# vow=['a','e','i','o','u']
# dx,dy=[-1,1,0,0],[0,0,1,-1]

#from cmath import sqrt
# from collections import deque, Counter, OrderedDict,defaultdict
# from heapq import nsmallest, nlargest, heapify,heappop ,heappush, heapreplace
# from math import ceil,floor,log,sqrt,factorial,pow,pi,gcd,log10,atan,tan
#from bisect import bisect_left,bisect_right
#import numpy as np

def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()

T=int(input())
while T>0:
    n=int(input())
    Arr=get_array()
    Arr.sort()
    mini=min(Arr[-1],Arr[-2])-1
    print(min(mini,n-2))
    T-=1