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.util.*;
import java.io.*;
public class Main
{
    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; 
        } 
    }
    static class Pair
    {
        int f,s;
        char c,p;
        Pair(int f,int s,char c)
        {
            this.f=f;
            this.s=s;
            this.c=c;
        }
    }
    public static int bs(int b[],int k,int j)
    {
        if(j<0)
        return -1;
        int l=0,r=j+1;
        while(r-l>1)
        {
            int mid=(l+r)/2;
            if(b[mid]>k)
            r=mid;
            else
            l=mid;
        }
        return b[l]<=k?l:-1;
    }
    public static void swapByRandom(int []arr,int n)
    {
        Random rand=new Random();
        for(int i=0;i<n;i++)
        {
            int ind=rand.nextInt(n);
            int temp=arr[i];
            arr[i]=arr[ind];
            arr[ind]=temp;
        }
    }
    static class comp implements Comparator<Pair>
    {
        public int compare(Pair p1,Pair p2)
        {
            if(p1.s==p2.s)
            return p2.f-p1.f;
            return p1.s-p2.s;
        }
    }
    static int seg[];
    public static void buildSegmentTree(int arr[],int l,int r,int ind)
    {
        if(l==r)
        {
            seg[ind]=arr[l];
            return;
        }
        int mid=(l+r)/2;
        buildSegmentTree(arr,l,mid,2*ind+1);
        buildSegmentTree(arr,mid+1,r,2*ind+2);
        seg[ind]=Math.min(seg[2*ind+1],seg[2*ind+2]);
    }
    public static int query(int l,int r,int s,int e,int ind)
    {
        if(r<l||e<l||s>r)
        return Integer.MAX_VALUE;
        if(l==r)
        return seg[ind];
        int mid=(l+r)/2;
        return Math.min(query(l,mid,s,e,2*ind+1),query(mid+1,r,s,e,2*ind+2));
    }
    public static void main(String args[])
    {
        FastReader fs=new FastReader();
        PrintWriter pw=new PrintWriter(System.out);
        int t=fs.nextInt();
        //int t=1;
        while(t-->0)
        {
            int n=fs.nextInt();
            int x=fs.nextInt();
            int a[]=new int[n];
            for(int i=0;i<n;i++)
            a[i]=fs.nextInt();
            int ptr=n-1;
            while(ptr>0&&a[ptr]>=a[ptr-1])
            ptr--;
            if(ptr==0)
            {
                pw.println(0);
                continue;
            }
            ptr--;
            int lis[]=new int[ptr+1];
            int par[]=new int[ptr+1];
            Arrays.fill(lis,1);
            Arrays.fill(par,-1);
            for(int i=0;i<=ptr;i++)
            {
                for(int j=0;j<i;j++)
                {
                    if(a[j]<a[i]&&a[j]>x&&a[i]>x)
                    {
                        //if(lis[j]+1>lis[i])
                        if(par[i]==-1)
                        {
                            lis[i]=lis[j]+1;
                            par[i]=j;
                        }
                        else if(a[j]>a[par[i]])
                        {
                            //lis[i]=Math.max(lis[i],lis[j]+1);
                            lis[i]=lis[j]+1;
                            par[i]=j;
                        }
                    }
                }
            }
            int min=Integer.MAX_VALUE;
            for(int i=ptr;i>=0;i--)
            {
                int ta[]=new int[n];
                for(int j=0;j<n;j++)
                ta[j]=a[j];
                int ind=i;
                while(par[ind]!=-1)
                {
                    ta[ind]=ta[par[ind]];
                    ind=par[ind];
                }
                if(ta[ind]>x)
                ta[ind]=x;
                boolean isSorted=true;
                for(int j=1;j<n;j++)
                {
                    if(ta[j]<ta[j-1])
                    isSorted=false;
                }
                if(isSorted)
                min=Math.min(min,lis[i]);
            }
            pw.println(min==Integer.MAX_VALUE?-1:min);
        
        }
        pw.flush();
        pw.close();
    }
}