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.io.*;
import java.util.*;
 
public class Main {
	public static void merge(int[] arr, int first,int mid,int last){

		int a[]=new int[mid-first+1];

		int b[]=new int[last-mid];

		// int c[]=new int[mid-first+1];

		// int d[]=new int[last-mid];

		int pahela,dusra;	
		pahela=dusra=0;

		for(pahela=0;pahela<mid-first+1;pahela++)
		{
			a[pahela]=arr[first+pahela];
			// c[pahela]=indexes[first+pahela];
		} 

		for(dusra=0;dusra<last-mid;dusra++)
		{
			b[dusra]=arr[mid+1+dusra];
			// d[dusra]=indexes[mid+1+dusra];
		}

		pahela=0;
		dusra=0;
		int maha=first;

		while(pahela<mid-first+1 && dusra<last-mid)
		{
			if(a[pahela]<=b[dusra])
			{
				arr[maha]=a[pahela];
				// indexes[maha]=c[pahela];
				maha++;
				pahela++;
			}

			else
			{
				arr[maha]=b[dusra];
				// indexes[maha]=d[dusra];
				maha++;
				dusra++;
			}
		}

		while(pahela<mid-first+1)
		{
			arr[maha]=a[pahela];
			// indexes[maha]=c[pahela];
			maha++;
			pahela++;
		}

		while(dusra<last-mid){
			arr[maha]=b[dusra];
			// indexes[maha]=d[dusra];
			maha++;
			dusra++;
		}
	}
	public static void mergesort(int arr[],int first,int last)
	{
		if(first < last) {
		int mid=(first+last)/2;
		mergesort(arr,first,mid);
		mergesort(arr,mid+1,last);
		merge(arr,first,mid,last);
	}
	}
	public static void main(String[] args)throws IOException {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);
        
		int t = in.nextInt();
		int n,ans; int arr[];
		for(int i=0;i<t;i++)
		{
			n=in.nextInt();
			arr=new int[n];
			for(int j=0;j<n;j++)
			{
				arr[j]=in.nextInt();
			}
			mergesort(arr,0,n-1);
			// Arrays.sort(arr);
			ans=Math.min(n-2,arr[n-2]-1);
			// ans= (ans==0) ? -1 : ans;
			out.println(ans);
		}

        out.close();
	}
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

    }

}