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.math.*;
import java.util.*;
import java.io.*;
  
public class A { 
  
    static int test = 10; // 0 for local testing, 1 for std input

    static BufferedReader in;
    static PrintWriter out = new PrintWriter(System.out);
    static String file = "../in";
    static int inf = 1_000_000;

    static void swap(int[]ary, int i, int j)
    {
        int t = ary[i];
        ary[i] = ary[j];
        ary[j] = t;
    }
    
    static String[] split() throws Exception
    {
        return in.readLine().split(" ");
    }

    static int readInt() throws Exception
    {
        return Integer.valueOf(in.readLine());
    }

    static int[] toIntArray() throws Exception
    {
        String[] sp = split();
        int n = sp.length;
        int[] ary = new int[n];
        for(int i = 0; i < n; i++) ary[i] = Integer.valueOf(sp[i]);
        return ary;
    }

    static long[] toLongArray() throws Exception
    {
        String[] sp = split();
        int n = sp.length;
        long[] ary = new long[n];
        for(int i = 0; i < n; i++) ary[i] = Long.valueOf(sp[i]);
        return ary;
    }    

    public static void main(String[] args) throws Exception
    {
        int _k = Integer.valueOf("1");
        if(test > 0) in = new BufferedReader(new InputStreamReader(System.in));
        else in = new BufferedReader(new FileReader(file));
        if(test < 0) {String[] str = in.readLine().split(" ");
            char[] cc = str[0].toCharArray();
        }

        
        
        /****************************************************/  
        /****************************************************/
        /****************************************************/
        /****************************************************/

        int t = readInt();
        
        while(t-- > 0)
        {
            int[] ary = toIntArray();
            int n = ary[0], k = ary[1];
            String str = in.readLine();
            int i = 0, j = n - 1;
            while(k > 0 && i < j){
                if(str.charAt(i) == str.charAt(j))
                {
                    i++;
                    j--;
                    k--;
                }
                else break;
            }
            if(k == 0 && i <= j) out.println("YES");
            else out.println("NO");
        }

        
        /****************************************************/
        /****************************************************/
        /****************************************************/
        /****************************************************/

        out.flush();
    }

    static boolean dfs(int pos, Map<Integer, List<Integer>> map, 
        boolean[] visited, boolean[] onstack,
        Stack<Character> stack)
    {
        if(onstack[pos]) return false;
        if(visited[pos]) return true;
        visited[pos] = true;
        onstack[pos] = true;
        for(int next : map.get(pos))
        {
            if(!dfs(next, map, visited, onstack, stack)) return false;
        }
        onstack[pos] = false;
        stack.push((char)('a' + pos));
        return true;
    }
}