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
#include <bits/stdc++.h>
#define endl "\n"
#define int long long
  
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int,int> pii;

template<int D, typename T>
struct Vec : public vector<Vec<D - 1, T>> {
  static_assert(D >= 1, "Vector dimension must be greater than zero!");
  template<typename... Args>
  Vec(int n = 0, Args... args) : vector<Vec<D - 1, T>>(n, Vec<D - 1, T>(args...)) {
  }
};

template<typename T>
struct Vec<1, T> : public vector<T> {
  Vec(int n = 0, const T& val = T()) : vector<T>(n, val) {
  }
};

template<typename T>
void printv(vector<T> v) {
  for (auto e : v) {
    cout << e << " ";
  } cout << endl;
}
 
template<typename T>
void printvv(vector<T> vv) {
  for (int i=0; i<vv.size(); i++) {
    cout << i << ": ";
    for (auto e : vv[i]) {
      cout << e << " ";
    } cout << endl;
  }
}

int cnt_leq_x(vi &a, int x) {
  int ret = upper_bound(a.begin(), a.end(), x) - a.begin();
  return ret;
}

int cnt_lt_x(vi &a, int x) {
  int ret = lower_bound(a.begin(), a.end(), x) - a.begin();
  return ret;
}

int cnt_geq_x(vi &a, int x) {
  int ret = a.end() - lower_bound(a.begin(), a.end(), x);
  return ret;
}

int cnt_gt_x(vi &a, int x) {
  int ret = a.end() - upper_bound(a.begin(), a.end(), x);
  return ret;
}

struct FenwickTree{ 
  int n;
  vi arr;

  FenwickTree(int n) {
    this->n = n;
    arr.assign(n, 0);
  }

  FenwickTree(vi a) : FenwickTree(a.size()) {
    for (int i=0; i<a.size(); i++) {
      add(i, a[i]);
    }
  }

  int sum(int i) {
    int ret = 0;
    while (i>0) {
      ret += arr[i];
      i -= i & -i;
    }
    return ret;
  }

  int sum(int l, int r) {
    return sum(r) - sum(l-1);
  }

  void add(int i, int delta) {
    while (i < n) {
      arr[i] += delta;
      i += i & -i;
    }
  }
};

typedef int item; 
struct segtree{
  int size;
  vector<item> arr;
 
  const item identity = 1;
 
  item single (int v) {
    return v;
  }
 
  item merge(item a, item b) {
    return a*b;
  }
 
  void init(int n) {
    size = 1;
    while (size < n) size *= 2;
    arr.assign(2*size, identity);
  }
 
  void build(vi &a, int x, int lx, int rx) {
    if (rx - lx == 1) {
      if (0<=lx && lx < a.size()) {
        arr[x] = single(a[lx]);
      }
      return;
    }
    int m = (lx + rx) / 2;
    build(a, 2*x+1, lx, m);
    build(a, 2*x+2, m, rx);
 
    arr[x] = merge(arr[2*x+1], arr[2*x+2]);
  }
 
  void build(vi &a) {
    build(a, 0, 0, size);
  }
 
  void set(int i, int v, int x, int lx, int rx) {
    if (rx - lx == 1) {
      arr[x] = single(v);
      return;
    }
 
    int m = (lx + rx) / 2;
 
    if (i < m) set(i, v, 2*x+1, lx, m);
    else set(i, v, 2*x+2, m, rx);
 
    arr[x] = merge(arr[2*x+1], arr[2*x+2]);
  }
 
  void set(int i, int v) {
    set(i, v, 0, 0, size);
  }
 
  item calc(int l, int r, int x, int lx, int rx) {
    if (r<=lx || rx <= l) return identity; 
    if (l<=lx && rx <= r) return arr[x];
 
    int m = (lx+rx) / 2;
    
    item left = calc(l, r, 2*x+1, lx, m);
    item right = calc(l, r, 2*x+2, m, rx);
 
    return merge(left, right);
  }
 
  item calc(int l, int r) {
    return calc(l, r, 0, 0, size);
  }
 
  int find(int k, int l, int x, int lx, int rx) {
    if (rx - lx == 1) {
      if (0<=lx && lx<=size) {
        if (arr[x] >= k && lx >=l) return lx;
        else return -1;
      }
    }
    int m = (lx + rx) / 2;
    int left = arr[2*x+1];
 
    if (l<m && k<=left) {
      int temp = find(k,l,2*x+1,lx,m);
      if (temp == -1) return find(k,l,2*x+2,m,rx);
      else return temp;
    } else {
      return find(k,l,2*x+2,m,rx);
    }
  }
 
  int find(int k, int l) {
    return find(k,l,0,0,size);
  }
};


void io_util() {
  #ifndef ONLINE_JUDGE
  freopen("input.txt", "r", stdin);
  // freopen("output.txt", "w", stdout);
  #endif
  ios_base::sync_with_stdio(false); 
  cin.tie(nullptr); 
  cout.precision(17);
}

///////////////////////////////////////////////////////////////////////

int t, n, m, k, x;
vi a;


bool is_sorted(vi &a) {
  vi b = a;
  sort(b.begin(), b.end());
  int n = a.size();
  bool ret = true;
  for (int i=0; i<n; i++) {
    if (a[i] != b[i]) ret = false;
  }
  return ret;
}

signed main() {
  io_util();
  
  cin >> t;
  while (t--) {
    cin >> n >> x;
    a.resize(n);
    for (int i=0; i<n; i++) cin >> a[i];

    if (is_sorted(a)) {
      cout << 0 << endl;
      continue;
    }

    int ans = 1e18;

    for (int i=0; i<n; i++) {
      vi b = a;
      int y = x;
      
      int cnt = 0;
      for (int j=i; j<n; j++) {
        if (b[j] > y) {
          swap(b[j],y);
          cnt++;
        }
        
        if (is_sorted(b)) {
          ans = min(ans, cnt);
        }

      }
    }

    if (ans == 1e18) {
      cout << -1 << endl;
    }
    else {
      cout << ans << endl;
    }

  }
 
  return 0;
}
