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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    // Hashmap
    // m.put(arr[i],m.get(arr[i])!=null?m.get(arr[i])+1:1);
    public static void main(String[] args) {
        FastReader in = new FastReader();
        int t=in.nextInt();
        while (t-->0)
        {
            int n=in.nextInt();
            int k=in.nextInt();
            String input=in.next();
            if(k==0)
            {
                System.out.println("YES");
            }
            else if(2*k+1<=n)
            {
                boolean b=false;
                for(int i=0,j=n-1;i<k;i++,j--)
                {
                    if(input.charAt(i)!=input.charAt(j))
                    {
                        System.out.println("NO");
                        b=true;
                        break;
                    }
                }
                if(!b)
                    System.out.println("YES");
            }
            else {
                System.out.println("NO");
            }

        }
    }
    static class Pair
    {
        // Return a map entry (key-value pair) from the specified values
        public static <T, U> Map.Entry<T, U> of(T first, U second)
        {
            return new AbstractMap.SimpleEntry<>(first, second);
        }
    }
    static long log(long a,long b)
    {
        long ret=0;
        while(a>0)
        {
            a/=b;
            ret++;
        }
        return ret;
    }
    static long log2(int a)
    {
        return (int) (Math.log(a)/Math.log(2));
    }
    static boolean isodd(int n)
    {
        if((n&1)==1)
            return true;
        else
            return false;
    }
    static int longestPrefixSuffix(String s)
    {
        int n = s.length();

        // If n is less than 2
        if(n < 2) {
            return 0;
        }

        int len = 0;
        int i = (n + 1)/2;

        // Iterate i till n
        while(i < n)
        {

            // If s[i] is equal to
            // s[len]
            if(s.charAt(i) == s.charAt(len))
            {
                ++len;
                ++i;
            }
            else
            {
                i = i - len + 1;
                len = 0;
            }
        }

        // Return len
        return len;

    }
    static boolean isPowerOfTwo(int x)
    {
        /* First x in the below expression is
        for the case when x is 0 */
        return x != 0 && ((x & (x - 1)) == 0);
    }
    public static int upperbound(int arr[],int key)
    {
        int low=0;
        int high=arr.length-1;
        while(low<=high)
        {
            int mid=(low+high)/2;
            if(arr[mid]>key)
            {
                high=mid-1;
            }else if(arr[mid]==key)
            {
                low=mid+1;
            }
            else
            {
                low=mid+1;
            }
        }
        return low;
    }
    public static int lowerbound(int arr[],int key)
    {
        int low=0;
        int high=arr.length-1;
        while(low<=high)
        {
            int mid=(low+high)/2;
            if(arr[mid]>key)
            {
                high=mid-1;
            }else if(arr[mid]==key)
            {
                high=mid-1;
            }
            else
            {
                low=mid+1;
            }
        }
        return low;
    }
    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;
        }
    }
}
