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 sys
import bisect as bi
import math
from collections import defaultdict as dd
import queue 
import heapq
import itertools
##import io
##import os
##import operator
input=sys.stdin.readline
##input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import random
##sys.setrecursionlimit(10**7)
##fo=open("output2.txt","w")
##fi=open("input2.txt","w")
mo=10**9+7
def cin():return map(int,sin().split())
def ain():return list(map(int,sin().split()))
def sin():return input().strip()
def inin():return int(input())
##def pref(a,n,f):
##    pre=[0]*n
##    if(f==0):         ##from beginning
##        pre[0]=a[0]
##        for i in range(1,n):
##            pre[i]=a[i]+pre[i-1]
##    else:              ##from end
##        pre[-1]=a[-1]
##        for i in range(n-2,-1,-1):
##            pre[i]=pre[i+1]+a[i]
##    return pre
##-----------------------------------------------------------------------------------------------------------------------
##l=[0]*(2*10**6+1);cur=0
##for i in range(200000):
##        if(i+cur<=2*10**6):
##                l[cur]=i
##                cur+=i+1
##
####print(l[0:15])
##for i in range(2*10**6-1,0,-1):
##        if(l[i]==0 ):
##                l[i]=l[i+1]+1
####print(l[0:15])
##dp=[-1]*(10**6+1)
##def solve(dp,i,ch):
##        print(i,ch)
##        if(i==0):
##                dp[0]=0
##                return 0
##        elif(i==1):
##                dp[i]=1
##                return 1
##        if(dp[i]!=-1):
##                return dp[i]
##        elif(i==ch*(ch+1)//2):
##                dp[i]=ch
##                return dp[i]
##        else:
##                ans=min(solve(dp,i+ch,ch+1),solve(dp,i-1,ch+1))+1
##                dp[i]=ans
##                return ans
##dp[1]=1;dp[2]=3;dp[3]=2
##solve(dp,100,0)
##print(dp[0:10])
##for  _ in range(inin()):
##        n=inin()
##        print(l[n])
##        
for _ in range(inin()):
##        n,x=cin()
##        l=ain()
##        sor=sorted(l)
##        pos=bi.bisect_left(sor,x)
##        inv=0
##        invpos=[]
##        for i in range(0,n-1):
##                if(l[i+1]<l[i]):
##                        inv+=1
##                        invpos+=[i]
##        c=0
##        print(sor,pos,invpos)
##        for i in range(n):
##                
##                if(inv and i>=pos):
##                        print(l,c,inv,pos)
##                        c+=1
##                        l[i],x=x,l[i]
##                        if(invpos[0]==i): 
##                                invpos.pop(0)
##                                inv-=1
##                                sor=sorted(l)
##                                pos=bi.bisect_right(sor,x)
##                                print("JI",invpos,sor,pos)
##                        
##        if(sorted(l)==l):
##                print(c)
##        else:
##                print(-1)
##                        
##                
    n,x=cin()
    ar=ain()
    mo=0
    while(1):
        if ar == sorted(ar):
            print(mo)
            break
        if max(ar)<=x:
            print(-1)
            break
        for i in range(n):
            if ar[i]>x:
                ar[i],x=x,ar[i]
                mo+=1
                break
  
                



        
                
        
                
        
                
            

            
    
##-----------------------------------------------------------------------------------------------------------------------#
##def msb(n):n|=n>>1;n|=n>>2;n|=n>>4;n|=n>>8;n|=n>>16;n|=n>>32;n|=n>>64;return n-(n>>1) #2 ki power
##def pref(a,n,f):
##    pre=[0]*n
##    if(f==0):         ##from beginning
##        pre[0]=a[0]
##        for i in range(1,n):
##            pre[i]=a[i]+pre[i-1]
##    else:              ##from end
##        pre[-1]=a[-1]
##        for i in range(n-2,-1,-1):
##            pre[i]=pre[i+1]+a[i]
##    return pre
##maxint=10**24
##def kadane(a,size):
##    max_so_far = -maxint - 1
##    max_ending_here = 0
##
##    for i in range(0, size):
##        max_ending_here = max_ending_here + a[i]
##        if (max_so_far < max_ending_here):
##            max_so_far = max_ending_here
##
##        if max_ending_here < 0:
##            max_ending_here = 0
##    return max_so_far
##def modFact(n, p):
##    if(n<0):return 0
##    if n >= p: return 0
##    result = 1
##    for i in range(1, n + 1):result = (result * i) % p
##    return result
##def ncr(n, r, p):
##    if(n<r or n<0): return 0
##    num = den = 1 
##    for i in range(r): 
##        num = (num * (n - i)) % p ;den = (den * (i + 1)) % p 
##    return (num * pow(den,p - 2, p)) % p 
