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.StringTokenizer;

public class Task1 {
    FastScanner scanner;
    PrintWriter writer;

    public void run() {
        try {
            writer = new PrintWriter(System.out);
            scanner = new FastScanner(System.in);

            solution();

            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    class FastScanner {
        BufferedReader reader;

        StringTokenizer tokenizer;
        FastScanner(File file) throws FileNotFoundException {
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
        }

        FastScanner(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
        }

        boolean hasNext() {
            boolean result = false;
            if (tokenizer != null && tokenizer.hasMoreTokens()) {
                result =  true;
            } else {
                String newLine = null;
                try {
                    newLine = reader.readLine();
                    while(newLine != null) {
                        newLine = newLine.trim();
                        if (!newLine.equals("")) {
                            break;
                        }
                        newLine = reader.readLine();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }

                if (newLine != null) {
                    result = true;
                    tokenizer = new StringTokenizer(newLine);
                }
            }

            return result;
        }

        String next() {
            hasNext();
            return tokenizer.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }
    }

    public static void main(String[] args) {
        new Task1().run();
    }

    public boolean isSorted(int[] array, int l, int r) {
        boolean result = true;
        for (int i = l; i <= r - 1; ++i) {
            if (array[i + 1] < array[i]) {
                result = false;
                break;
            }
        }
        return result;
    }

    public void sol(int[] a, int n, int x) {
        if (isSorted(a, 0, n-1)) {
            writer.println("0");
            return;
        }

        boolean result = true;
        int cnt = 0;
        for (int i = 0; i < n - 1; ++i) {
            if (a[i] > x) {
                int temp = a[i];
                a[i] = x;
                x = temp;
                cnt++;
                if (!isSorted(a, 0, i + 1)) {
                    result = false;
                    break;
                }
                if (isSorted(a, 0, n-1)) {
                    break;
                }
            } else if (a[i] > a[i + 1]) {
                result = false;
                break;
            }
        }
        String resultStr = "";
        if (result) {
            resultStr = "" + cnt;
        } else {
            resultStr = "-1";
        }
        writer.println(resultStr);
    }

    public void solution() throws IOException {
        int t = scanner.nextInt();
        for (int i = 0; i < t; ++i) {
            int n = scanner.nextInt();
            int x = scanner.nextInt();
            int[] a = new int[n];
            for (int j = 0; j < n; ++j) {
                a[j] = scanner.nextInt();
            }
            sol(a, n, x);
        }
    }
}
