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 SolutionA{
       public static void main(String[] args) throws Exception{
               Fast sc=new Fast();
       StringBuilder sb=new StringBuilder();
        int t=sc.nextInt();
        while(t-->0){
            int n=sc.nextInt();
            int k=sc.nextInt();
 
            String s=sc.next();
            if(k==0){
              System.out.println("YES");
            }
           else if(n%2==0 && k==n/2){
              System.out.println("NO");
            }
            else{
                 
                    boolean ok=true;
                    for(int i=0;i<n;i++){
                      if(k>0){
                      if(s.charAt(i)!=s.charAt(n-1-i))ok=false;
                      k--;
                    }
                    }
                    if(ok==false)System.out.println("NO");
                    else System.out.println("YES");
                      
               
              }
        }
 
    }
 
 
static void ReverSort(int[] ar){
    ArrayList<Integer> al=new ArrayList<>();
    for(int i=0;i<ar.length;i++){
        al.add(ar[i]);
    }
 
    Collections.sort(al);
      int j=0;
    for(int i=al.size()-1;i>=0;i--){
 
        ar[j]=al.get(i);
        j++;
    }
}
static void Sort(int[] ar){
    ArrayList<Integer> al=new ArrayList<>();
    for(int i=0;i<ar.length;i++){
        al.add(ar[i]);
    }
 
    Collections.sort(al);
      int j=0;
    for(int i=0;i<al.size();i++){
 
        ar[j]=al.get(i);
        j++;
     }
  }
 
 
static int gcd(int a,int b){
    if(b==0) return a;
    else return  gcd(b,a%b);
}
}
 
class Pair{
    int x, y;
     Pair(int x,int y){
        this.x=x;
        this.y=y;
     }
}
 
class SortPair implements Comparator<Pair>{
 
    public int compare(Pair p1, Pair p2){
        return p1.y-p2.y;
    }
}
 
class Fast{
  BufferedReader br; 
  StringTokenizer st;
  public Fast(){ 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; 
        } 
}