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.lang.*;
import java.io.*;

public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
	try{
	    InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
	    int t=Integer.parseInt(in.next());
	    while(t-- >0)
	    {
	       int n=Integer.parseInt(in.next()); 
	       int k=Integer.parseInt(in.next());
	       String str=in.next();
	       if(k==0)
	       {
	           out.println("YES");
	       }
	       else{
	           int p=0;
	           boolean ans=false;
	           int q=str.length()-1;
	           char ch[]=str.toCharArray();
	               while(k!=0 && p<(q-1))
	               {
	                   if(k==1 && ch[p]==ch[q]) ans=true;
	                   if(ch[p]!=ch[q])
	                   {ans=false; break;}
	                    k--;
	                    p++;
	                    q--;
	               }
	               if(!ans)
	               {
	                   out.println("NO");
	               }
	               else{
	                   out.println("YES");
	               }
	       }
	    }
	   
	   
	    out.close();
	}
	catch(Exception e)
	{
	    return;
	}
	}
}



class FastReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private FastReader.SpaceCharFilter filter;

    public FastReader(InputStream stream) {
        this.stream = stream;
    }
     public int read() {

        if (numChars == -1) {
            throw new InputMismatchException();
        }

        if (curChar >= numChars) {

            curChar = 0;

            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }

            if (numChars <= 0) {
                return -1;
            }
        }

        return buf[curChar++];
    }
    
    public int nextInt() {

        int c = read();

        while (isSpaceChar(c)) {
            c = read();
        }
        int sgn = 1;

        if (c == '-') {
            sgn = -1;
            c = read();
        }

        int res = 0;

        do {
            if (c < '0' || c > '9') {
                throw new InputMismatchException();
            }

            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));

        return res * sgn;
    }
    
     public long nextLong() {

        int c = read();

        while (isSpaceChar(c)) {
            c = read();
        }
        
        int sgn = 1;

        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
         do {
            if (c < '0' || c > '9') {
                throw new InputMismatchException();
            }

            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }
    
    public String next() {

        int c = read();

        while (isSpaceChar(c)) {
            c = read();
        }

        StringBuilder res = new StringBuilder();

        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));

        return res.toString();
    }
    public boolean isSpaceChar(int c) {

        if (filter != null) {
            return filter.isSpaceChar(c);
        }

        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public interface SpaceCharFilter {

        public boolean isSpaceChar(int ch);

    }
}