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
import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class D {

    private static BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    private static BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
    private static StringTokenizer st;

    public static void main(String[] args) throws IOException {
        st = new StringTokenizer(reader.readLine());
        int T = Integer.parseInt(st.nextToken());
        for (int t = 0; t < T; t++) {
            st = new StringTokenizer(reader.readLine());
            int n = Integer.parseInt(st.nextToken());
            int x = Integer.parseInt(st.nextToken());
            List<Integer> smaller = new ArrayList<>();
            List<Integer> biggerOrEqual = new ArrayList<>();
            boolean firstBiggerOrEqualSeen = false;
            boolean possible = true;
            int[] a = new int[n];
            st = new StringTokenizer(reader.readLine());
            for (int i = 0; i < n; i++) {
                a[i] = Integer.parseInt(st.nextToken());
                if (a[i] < x) {
                    smaller.add(a[i]);
                    if (firstBiggerOrEqualSeen) {
                        possible = false;
                    }
                } else {
                    biggerOrEqual.add(a[i]);
                    firstBiggerOrEqualSeen = true;
                }
            }
            for (int i = 0; i < smaller.size() - 1; i++) {
                if (smaller.get(i) > smaller.get(i + 1)) {
                    possible = false;
                }
            }
            if (!possible) {
                writer.write("-1");
                writer.newLine();
                continue;
            }

            int swaps = 0;
            for (int i = 0; i < biggerOrEqual.size(); i++) {
                if (sorted(biggerOrEqual)) {
                    break;
                }
                if (biggerOrEqual.get(i) > x) {
                    int temp = biggerOrEqual.get(i);
                    biggerOrEqual.set(i, x);
                    x = temp;
                    swaps++;
                }
            }
            for (int i = 0; i < biggerOrEqual.size() - 1; i++) {
                if (biggerOrEqual.get(i) > biggerOrEqual.get(i + 1)) {
                    possible = false;
                }
            }
            if (!possible) {
                writer.write("-1");
                writer.newLine();
                continue;
            }

            writer.write(Integer.toString(swaps));
            writer.newLine();
        }
        writer.flush();
    }

    static boolean sorted(List<Integer> list) {
        for (int i = 0; i < list.size() - 1; i++) {
            if (list.get(i) > list.get(i + 1)) {
                return false;
            }
        }
        return true;
    }
}
