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.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
 
public class Contest {
 
    //private static List<Integer> results = new ArrayList<>();
    //private static Map<Integer, List<Integer>> map = new HashMap<>();
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //String line = sc.nextLine();
        //int n = Integer.valueOf(line);
 
        String line = sc.nextLine();
        /*String[] split = line.split(" ");
        int w = Integer.valueOf(split[0]);
        int h = Integer.valueOf(split[1]);*/
        Integer q = Integer.valueOf(line);
 
        for (int i = 0; i < q; i++) {
            line = sc.nextLine();
            Integer n = Integer.valueOf(line);
            line = sc.nextLine();
            String[] split = line.split(" ");
            solve(n, split);
        }
    }
 
    private static void solve(int n, String[] split) {
        List<Integer> lengths = new ArrayList<>();
        for (int i = 0; i < split.length; i++) {
            lengths.add(Integer.valueOf(split[i]));
        }
        Collections.sort(lengths);
        if (n == 2) {
            System.out.println(0);
            return;
        }
        int first = lengths.get(lengths.size()-1);
        int second = lengths.get(lengths.size()-2);
        int minimum = Math.min(first, second)-1;
        // System.out.println(minimum + "minimum");
        int blocks = lengths.size() - 2;
        //System.out.println(blocks + "blocks");
        System.out.println(Math.min(minimum, blocks));
    }
 
    public static boolean isPrime(int num) {
        if (num > 2 && num % 2 == 0) {
            //System.out.println(num + " is not prime");
            return false;
        }
        int top = (int) Math.sqrt(num) + 1;
        for (int i = 3; i < top; i += 2) {
            if (num % i == 0) {
                //System.out.println(num + " is not prime");
                return false;
            }
        }
        //System.out.println(num + " is prime");
        return true;
    }
 
    private static void doneList(List<Integer> a) {
        StringBuilder builder = new StringBuilder("");
        for (int i = 0; i < a.size(); i++) {
            builder.append(a.get(i) + 1).append(" ");
        }
        System.out.println(builder.toString().substring(0, builder.toString().length() - 1));
    }
 
    private static void doneArray(Integer[] a) {
        StringBuilder builder = new StringBuilder("");
        for (int i = 2; i < a.length; i++) {
            builder.append(a[i]).append(" ");
        }
        System.out.println(builder.toString().substring(0, builder.toString().length() - 1));
    }
 
    private static void done() {
        System.out.println("-1");
    }
 
    private static int lowerBound(int[] a, int low, int high, int element) {
        while (low < high) {
            int middle = low + (high - low) / 2;
            if (element > a[middle]) {
                low = middle + 1;
            } else {
                high = middle;
            }
        }
        return low;
    }
 
    private static int upperBound(int[] a, int low, int high, int element) {
        while (low < high) {
            int middle = low + (high - low) / 2;
            if (a[middle] > element) {
                high = middle;
            } else {
                low = middle + 1;
            }
        }
        return low;
    }
 
}