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>
// John Lewis
// Date:
// Program:

import com.sun.org.apache.xerces.internal.xni.XMLDocumentFragmentHandler;
import java.util.*;
import java.io.*;

public class Main {

    public static void main(String[] args) throws IOException {
        input.init(System.in);
		PrintWriter out = new PrintWriter(System.out);
        // Variables
        int numQ = input.nextInt();
		int numPlanks;
		//int[] plankLengths;
		int thirdMax, secondMax, max;
		
		for (int i = 0; i < numQ; i++) {
			thirdMax = secondMax = max = 0;
			numPlanks = input.nextInt();
			//plankLengths = new int[numPlanks];
			for (int j = 0; j < numPlanks; j++) {
				int length = input.nextInt();
				//plankLengths[j] = input.nextInt();
				if (length < max && length > secondMax)
					secondMax = length;
				else if (length >= max){
					int temp = max;
					max = length;
					thirdMax = secondMax;
					secondMax = temp;
				}
				else if (length > thirdMax)
					thirdMax = length;
					
			}
			//System.out.printf("third max: %d second max: %d max: %d\n", thirdMax, secondMax, max );
			if (numPlanks < 3){
				out.println(0);
				continue;
			}
			else{
				if (secondMax  >= numPlanks - 1)
						out.println(numPlanks-2);
				else if (secondMax <= 1)
					out.println(0);
				else
					out.println(secondMax-1);
			}
//			Arrays.sort(plankLengths);
//			// 2 2 3 3 4
//			if (plankLengths[numPlanks-2] > 1){
//				int greatestPos = numPlanks - 2;
////				while (greatestPos > 0){
////					System.out.println("\ngreatest Possible: " + greatestPos + " PlankLength[GreatestPos]: " + plankLengths[greatestPos]);
//					if (plankLengths[greatestPos] >= greatestPos + 1){
//						out.println(greatestPos);
//					}
//					else{
//						out.println(plankLengths[greatestPos]-1);
//					}
////					greatestPos -= 1;
////				}
////				if (greatestPos == 0){
////					out.println(0);
////				}
//				
//			}
//			else{
//				out.println(0);
//			}
		}
		out.close();
    } // END MAIN
}
class input {
	
	static BufferedReader reader;
	static StringTokenizer tokenizer;

	/**
	 * call this method to initialize reader for InputStream
	 */
	static void init(InputStream input) {
		reader = new BufferedReader(
			new InputStreamReader(input));
		tokenizer = new StringTokenizer("");
	}

	/**
	 * get next word
	 */
	static String next() throws IOException {
		while (!tokenizer.hasMoreTokens()) {
			//TODO add check for eof if necessary
			tokenizer = new StringTokenizer(
				reader.readLine());
		}
		return tokenizer.nextToken();
	}
	
	static String nextLine() throws IOException {
		return reader.readLine();
	}
	
	static int nextInt() throws IOException {
		return Integer.parseInt(next());
	}
	
	static double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
	
	static long nextLong() throws IOException {
		return Long.parseLong(next());
	}
}
