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
// package Education99;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.*;
public class typeD1{
	static int[][] dp = new int[501][501];
	
	static int helper(int[] arr, int n , int i, int k){
		if(i==n){
			return 0;
		}
		if(dp[i][k]!=-1)
		  return dp[i][k];
		  
		if(i==0){
		    int ans1= 600;
		    int ans2 = helper(arr,n,i+1,k);
		    if(arr[i]>k){
	     	int t = arr[i];
			arr[i]=k;
			k = t;
		     ans1 = 1 + helper(arr,n,i+1,k);
		    t = arr[i];
			arr[i]=k;
			k = t;
		    }
			dp[i][k] = Math.min(ans1,ans2);
			return dp[i][k];	
		}
		else if(arr[i]>=arr[i-1]){
			int ans1 = 600;
			int ans2 = helper(arr,n,i+1,k);
			
			if(k>=arr[i-1]  && k<arr[i] ){
			int t = arr[i];
			arr[i]=k;
			k = t;
		     ans1 = 1 + helper(arr,n,i+1,k);
		    t = arr[i];
			arr[i]=k;
			k = t;
			}

			dp[i][k] = Math.min(ans1,ans2);
			return dp[i][k];
		}
		
		else if(k>=arr[i-1] && k<arr[i]){
		  	int t = arr[i];
			arr[i]=k;
			k = t;
		    int ans1 = 1 + helper(arr,n,i+1,k);
		    t = arr[i];
			arr[i]=k;
			k = t;
		 	dp[i][k] = ans1;
		 	return dp[i][k];
		}
		
		else{
			dp[i][k]= 600;
			return 600;
		} 
	}
	
	public static void main(String[] args) {
		FastReader s = new FastReader();
		int T = s.nextInt();
		for(int t =0;t<T;t++) {
			int n = s.nextInt(), x = s.nextInt();
			int[] arr = new int[n];
			for(int i=0;i<n;i++)
				arr[i]=s.nextInt();
			
			for(int i=0;i<=n;i++){
		        for(int j=0;j<=500;j++){
		        	dp[i][j]= -1;
		        }
		    }  
	        int ans = helper(arr,n,0,x);
	        if(ans>=n)
	         ans =-1;
	        System.out.println(ans);
	        
	    }
			
		
	}
	static class FastReader 

	{ 
	    BufferedReader br; 
	    StringTokenizer st; 

	    public FastReader() 
	    { 
	        br = new BufferedReader(new
	                 InputStreamReader(System.in)); 
	    } 

	    String next() 
	    { 
	        while (st == null || !st.hasMoreElements()) 
	        { 
	            try
	            { 
	                st = new StringTokenizer(br.readLine()); 
	            } 
	            catch (IOException  e) 
	            { 
	                e.printStackTrace(); 
	            } 
	        } 
	        return st.nextToken(); 
	    } 

	    int nextInt() 
	    { 
	        return Integer.parseInt(next()); 
	    } 

	    long nextLong() 
	    { 
	        return Long.parseLong(next()); 
	    } 

	    double nextDouble() 
	    { 
	        return Double.parseDouble(next()); 
	    } 

	    String nextLine() 
	    { 
	        String str = ""; 
	        try
	        { 
	            str = br.readLine(); 
	        } 
	        catch (IOException e) 
	        { 
	            e.printStackTrace(); 
	        } 
	        return str; 
	    } 
	} 

}
