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>
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
template <class T>
inline bool read(T &x) {
  int c = getchar();
  int sgn = 1;
  while (~c && c < '0' || c > '9') {
    if (c == '-') sgn = -1;
    c = getchar();
  }
  for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
  x *= sgn;
  return ~c;
}
template <class T>
inline T bigmul(T p, T e, T M) {
  long long int ret = 0;
  p = p % M;
  for (; e > 0; e >>= 1) {
    if (e & 1) ret = (ret + p) % M;
    p = (p + p) % M;
  }
  return (T)ret % M;
}
template <class T>
inline T bigmod(T p, T e, T M) {
  long long int ret = 1;
  p = p % M;
  for (; e > 0; e >>= 1) {
    if (e & 1) ret = (ret * p) % M;
    p = (p * p) % M;
  }
  return (T)ret % M;
}
template <typename T>
inline T POW(T B, T P) {
  if (P == 0) return 1;
  if (P & 1)
    return B * POW(B, P - 1);
  else
    return SQR(POW(B, P / 2));
}
template <typename T>
inline T Dis(T x1, T y1, T x2, T y2) {
  return sqrt(SQR(x1 - x2) + SQR(y1 - y2));
}
template <typename T>
inline T Angle(T x1, T y1, T x2, T y2) {
  return atan(double(y1 - y2) / double(x1 - x2));
}
inline int Set(int N, int pos) { return N = N | (1 << pos); }
inline int Reset(int N, int pos) { return N = N & ~(1 << pos); }
inline bool check(int N, int pos) { return (bool)(N & (1 << pos)); }
long long int arr[100010];
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  long long int n, k, p;
  cin >> k;
  while (k--) {
    cin >> n;
    for (int i = 0; i < n; i++) {
      cin >> arr[i];
    }
    sort(arr, arr + n);
    long long int mm = min(arr[n - 1], arr[n - 2]);
    cout << min(mm - 1, n - 2) << endl;
  }
  return 0;
}
