You are given a sequence a consisting of n integers a_1, a_2, ..., a_n, and an integer x. Your task is to make the sequence a sorted (it is considered sorted if the condition a_1 ≤ a_2 ≤ a_3 ≤ ... ≤ a_n holds).

To make the sequence sorted, you may perform the following operation any number of times you want (possibly zero): choose an integer i such that 1 ≤ i ≤ n and a_i > x, and swap the values of a_i and x.

For example, if a = [0, 2, 3, 5, 4], x = 1, the following sequence of operations is possible:

  1. choose i = 2 (it is possible since a_2 > x), then a = [0, 1, 3, 5, 4], x = 2; 
  2. choose i = 3 (it is possible since a_3 > x), then a = [0, 1, 2, 5, 4], x = 3; 
  3. choose i = 4 (it is possible since a_4 > x), then a = [0, 1, 2, 3, 4], x = 5. 



Calculate the minimum number of operations you have to perform so that a becomes sorted, or report that it is impossible.

Input

The first line contains one integer t (1 ≤ t ≤ 500) — the number of test cases.

Each test case consists of two lines. The first line contains two integers n and x (1 ≤ n ≤ 500, 0 ≤ x ≤ 500) — the number of elements in the sequence and the initial value of x.

The second line contains n integers a_1, a_2, ..., a_n (0 ≤ a_i ≤ 500).

The sum of values of n over all test cases in the input does not exceed 500.

Output

For each test case, print one integer — the minimum number of operations you have to perform to make a sorted, or -1, if it is impossible.

Example

Input


6
4 1
2 3 5 4
5 6
1 1 3 4 4
1 10
2
2 10
11 9
2 10
12 11
5 18
81 324 218 413 324


Output


3
0
0
-1
1
3
// #pragma GCC optimize("Ofast")  
// #pragma GCC target("avx,avx2,fma") 

#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>

using namespace std;
// using namespace __gnu_pbds;

#define BOOST() ios_base::sync_with_stdio(false); cin.tie(NULL)
#define FILL(v, x) memset(v, x, sizeof(v))
#define REP(i, a, b) for (int i = a; i < b; ++i)
#define SZ(v) ((int)(v).size())
#define ALL(v) (v).begin(), (v).end()
#define DB(x) cerr << __LINE__ << ": " << #x << " = " << (x) << "\n"
#define int long long
#define ii pair<int, int>
#define ff first
#define ss second
#define vi vector<int>
#define vvi vector<vi>
#define pb push_back
#define ub upper_bound
#define lb lower_bound

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v: V) os << v << " ";
    return os << "]\n";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L, R> P) {
    return os << "(" << P.ff << ", " << P.ss << ")\n";
}
template<class T> ostream& operator<<(ostream &os, set<T> S) {
    os << "{ ";
    for(auto s: S) os << s << " ";
    return os << "}\n";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L, R> M) {
    os << "{ ";
    for(auto m: M) os << "(" << m.ff << ":" << m.ss << ") ";
    return os << "}\n";
}
// template<class T> using ordered_set = 
//     tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

const int INF = 1LL << 60;
const int N   = 3e5 + 5 ;
const int MOD = 1e9 + 7;
// const int MOD = 998244353;

void solve() {
    int n, x, f = 0, mn = INF;
    cin >> n >> x;
    vi a(n);
    REP(i, 0, n) cin >> a[i];
    if(is_sorted(ALL(a))) f = 1, mn = 0;
    else {
        REP(i, 0, n) {
            if(a[i] > x) {
                vi b(a);
                int y = x, cnt = 1;
                swap(b[i], y);

                REP(j, i + 1, n) {
                    if(is_sorted(ALL(b))) break;
                    if(b[j] > y) {
                        swap(b[j], y);
                        cnt++;
                    }
                }
                
                int g = 1;
                REP(j, 1, n) if(b[j] < b[j-1]) g = 0;
                if(g) f = 1, mn = min(mn, cnt);
            }
        }
    }

    if(f) cout << mn << "\n";
    else cout << "-1\n";
}

int32_t main() {
    BOOST();
    int t = 0;
    if (!t) cin >> t;

    REP(_, 1, t + 1) {
        // cout << "Case #" << _ << ": ";
        solve();
    }
} 