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.
# by the authority of GOD     author: Kritarth Sharma #
import math
from collections import defaultdict,Counter
from itertools import permutations
from decimal import Decimal, localcontext
from collections import defaultdict


ii = lambda : int(input())
li = lambda:list(map(int,input().split()))
def main():
    for _ in range(ii()):
        n,k=li()
        s=input()
        c=0
        if k==0:
            print("YES")
        
        else:
            a1=s[:n//2]
            a2=s[n//2+1:][::-1]
            c=0
            for i in range(min(len(a1),len(a2))):
                if a1[i]==a2[i]:
                    c+=1
                else:
                    break
            if 2*k+1<=n and c>=k:
                print("YES")
            else:
                print("NO")

            


        
        




        



import os,sys
from io import BytesIO,IOBase
#Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
from math import gcd
def find(l):
    c=0
    for i in range(len(l)):
        if l[i]>1:
            c=i
            
            return c
    else:
        return None
def checkDivisibility(n, digit) : 
       
    # If the digit divides the 
    # number then return true 
    # else return false. 
    return (digit != 0 and n % digit == 0) 
       
# Function to check if 
# all digits of n divide 
# it or not 
def allDigitsDivide( n) : 
    nlist = list(map(int, set(str(n))))
    for digit in nlist : 

        if  digit!=0 and not (checkDivisibility(n, digit)) : 
            return False
    return True
def lcm(s):
    a=[int(d) for d in str(s)]
    lc = a[0]
    for i in a[1:]:
        if i!=0:
            lc = lc*i//gcd(lc, i)
    return(lc)
if __name__ == "__main__":
    main()


def random():
    """My code gets caught in plagiarism check for no reason due to the fast IO template, .
     Due to this reason, I am making useless functions"""
    rating=100
    rating=rating*100
    rating=rating*100
    
    print(rating)
def random():
    """My code gets caught in plagiarism check for no reason due to the fast IO template, .
     Due to this reason, I am making useless functions"""
    rating=100
    rating=rating*100
    rating=rating*100
    
    print(rating)
def random():
    """My code gets caught in plagiarism check for no reason due to the fast IO template, .
     Due to this reason, I am making useless functions"""
    rating=100
    rating=rating*100
    rating=rating*100
    
    print(rating)
def SieveOfEratosthenes(n):
        prime = [True for i in range(n+1)]
        p = 2
        while (p * p <= n):

            # If prime[p] is not 
            # changed, then it is a prime
            if (prime[p] == True):

                # Update all multiples of p
                for i in range(p * p, n+1, p):
                    prime[i] = False
            p += 1
        l=[1,]
        # Print all prime numbers
        for p in range(2, n+1):
            if prime[p]:
                l.append(p)
        return l
def fact(n): 
    return 1 if (n == 1 or n == 0) else n * fact(n - 1)  
def prime(n) : 
    if (n <= 1) : 
        return False
    if (n <= 3) : 
        return True
    if (n % 2 == 0 or n % 3 == 0) : 
        return False
    i = 5
    while(i * i <= n) : 
        if (n % i == 0 or n % (i + 2) == 0) : 
            return False
        i = i + 6
    return True