Kawashiro Nitori is a girl who loves competitive programming.

One day she found a string and an integer. As an advanced problem setter, she quickly thought of a problem.

Given a string s and a parameter k, you need to check if there exist k+1 non-empty strings a_1,a_2...,a_{k+1}, such that $$$s=a_1+a_2+… +a_k+a_{k+1}+R(a_k)+R(a_{k-1})+…+R(a_{1}).$$$ 

Here + represents concatenation. We define R(x) as a reversed string x. For example R(abcd) = dcba. Note that in the formula above the part R(a_{k+1}) is intentionally skipped.

Input

The input consists of multiple test cases. The first line contains a single integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.

The first line of each test case description contains two integers n, k (1≤ n≤ 100, 0≤ k≤ ⌊ n/2 ⌋) — the length of the string s and the parameter k.

The second line of each test case description contains a single string s of length n, consisting of lowercase English letters.

Output

For each test case, print "YES" (without quotes), if it is possible to find a_1,a_2,…,a_{k+1}, and "NO" (without quotes) otherwise.

You can print letters in any case (upper or lower).

Example

Input


7
5 1
qwqwq
2 1
ab
3 1
ioi
4 2
icpc
22 0
dokidokiliteratureclub
19 8
imteamshanghaialice
6 3
aaaaaa


Output


YES
NO
YES
NO
YES
NO
NO

Note

In the first test case, one possible solution is a_1=qw and a_2=q.

In the third test case, one possible solution is a_1=i and a_2=o.

In the fifth test case, one possible solution is a_1=dokidokiliteratureclub.
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;

        }

    }
    // public static boolean binarySearch(int[] a,int q)
    // {
    //     int l=0,hi=a.length-1,count=0;
    //     while(l<=hi)
    //     {
    //         int mid=l+(hi-l)/2;
            
    //         if(a[mid]==q)
    //         {
    //             count++;
    //             break;
    //         }
    //         else if(a[mid]>q)
    //         {
    //             hi=mid-1;
    //         }
    //         else{
    //             l=mid+1;
    //         }
    //     }
       
    //     if(count>0)
    //   return true;
    //   else
    //   return false;
    // }
    //   public static void printMazePaths(int sr, int sc, int dr, int dc, String psf) {
        
    //     if(sr==dr && sc==dc)
    //     {
    //         System.out.println(psf);
    //         return;
    //     }
    //     if(sr>dr || sc>dr)
    //     {
    //         return;
    //     }
       
    //         printMazePaths(sr,sc+1,dr,dc,psf+"h");
           
       
    //      printMazePaths(sr+1,sc,dr,dc,psf+"v");
    // }

  /*  public static int uniqueChar(String str)
    {
        String temp="";
        for(int i=0;i<4;i++)
        {
            if(temp.indexOf(str.charAt(i))==-1)
            {
                temp+=str.charAt(i);
            }
           
        }
         return temp.length();
    }*/
  /*  public static void mergeSort(int[] arr,int s,int e)
    {
        if(s<e)
        {   int mid=(s+e)/2;
            mergeSort(arr,s,mid);
            mergeSort(arr,mid+1,e);
            merge(arr,s,mid,e);
        }
    }
    public static void merge(int[] arr,int s,int mid, int e)
     {
        int  n1=mid-s+1;
        int n2=e-mid;
         
         int[] left=new int[n1];
         int[] right=new int[n2];
         
         for(int i=0;i<n1;i++)
         {
             left[i]=arr[s+i];
             
         }
         for(int i=0;i<n2;i++)
         {
             right[i]=arr[mid+1+i];
         }
         int i=0,j=0,k=s;
         while(i<n1 && j<n2)
         {  
             if(left[i]<=right[j])
             {
             arr[k]=left[i];
             i++;
             }
             else
             {
                 arr[k]=right[j];
                 j++;
             }
             k++;
         }
         while(i<n1)
         {
             arr[k]=left[i];
             i++;
             k++;
         }
         while(j<n2)
         {
             arr[k]=right[j];
             j++;
             k++;
         }
     } */
    //  public static void palindrome(int[] arr)
    //  {
    //      int s=0,l=arr.length-1,count=0;
    //      while(s<l)
    //      {
    //         if(arr[s]!=arr[l])
    //         {
    //         System.out.println("NO");
    //         count++;
    //         break;
    //         }
    //         s++;
    //         l--;
    //      }
    //      if(count==0)
    //      System.out.println("YES");
         
         
    //  }
    
    public static void main(String[] args)
    {
      FastReader s=new FastReader();
      int t=s.nextInt();
       while(t-->0)
       {
       int n=s.nextInt();
       int k=s.nextInt();
      
        String str=s.next();
        char[] ch=str.toCharArray();
        
        boolean count=true;
        for(int i=0;i<k;i++)
        {
            if(ch[i]!=ch[ch.length-i-1])
            {
                count=false;
            }
        }
        


     if((2*k+1<=n)&&(k==0))
     System.out.println("YES");
    else if((2*k+1<=n)&&(count))
     System.out.println("YES");
     else 
      System.out.println("NO");
     
    

    }   
  } 
}
     