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>
					import java.util.*;
					import java.lang.*;
					import java.text.DecimalFormat;
					import java.text.NumberFormat;
					import java.io.*;
					public class Solution {
						static PrintWriter out;
						static class FastReader {
					        BufferedReader br;
					        StringTokenizer st;
					        
					
					        public FastReader() {
					            br = new BufferedReader(new
					                    InputStreamReader(System.in));
					        }
					        
					        static long gcd(long a, long b){ 
							      if (b == 0) 
							        return a; 
							      return gcd(b, a % b);  
							}
					        
					        String next() {
					            while (st == null || !st.hasMoreElements()) {
					                try{
					                    st = new StringTokenizer(br.readLine());
					                }
					                catch (IOException  e) {
					                    e.printStackTrace();
					                }
					            }
					            return st.nextToken();
					        }
					        int nextInt() {
					            return Integer.parseInt(next());
					        }
					        long nextLong() {
					            return Long.parseLong(next());
					        }
						public int[] readIntArray(int n) {
								int[] arr = new int[n];
								for(int i=0; i<n; ++i)
									arr[i]=nextInt();
								return arr;
							}
					
					        double nextDouble() {
					            return Double.parseDouble(next());
					        }
					
					        String nextLine() {
					            String str = "";
					            try{
					                str = br.readLine();
					            }
					            catch (IOException e) {
					                e.printStackTrace();
					            }
					            return str;
					        }
					    }
						static int solve(int[] arr, int n, int pmax) {
							int x = pmax;
							int steps = x-1;
							if(n - 2 > steps) {
								return steps;
							}
							else {
								return n - 2;
							}
							
						}
						public static void main(String args[]) throws IOException {
					        long start = System.currentTimeMillis();
					        FastReader sc = new FastReader();
					        
					        	int t = sc.nextInt();
					        	
					        	while(t-- > 0 ) {
					        		int n = sc.nextInt();
					        		int[] arr = new int[n];
					        		int max = -1;
					        		int pmax = -1;
					        		for(int i=0;i<n;i++) {
					        			arr[i] = sc.nextInt();
					        		
					        			if(arr[i] >= max) {
					        				pmax = max;
					        				max = arr[i];
					        			}
					        			else if(arr[i] > pmax) {
					        				pmax = arr[i];
					        			}
					        		}
					        		//System.out.println(max+" "+ pmax);
					        		System.out.println(solve(arr, n, pmax));
					        	}
					        	long end = System.currentTimeMillis();
					        	NumberFormat formatter = new DecimalFormat("#0.00000");
					        	//System.out.print("Execution time is " + formatter.format((end - start) / 1000d) + " seconds");
					        }
					}
