# <-------------------------- IMPORTS -------------------------->
from heapq import heapify, heappush, heappop
from functools import cache
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque

# <-------------------------- CODE -------------------------->


class Trie:
    def __init__(self):
        self.children = defaultdict(lambda: None)
        self.isEnd = False


def getASCII(key):
    return ord(key) - ord('a')


def solve():
    int(input())
    words = input().split()
    s = input()
    n = len(s)

    # O(N) Trie insertion
    head = Trie()
    for word in words:
        ptr = head
        for ch in word:
            idx = getASCII(ch)
            if not ptr.children[idx]:
                ptr.children[idx] = Trie()
            ptr = ptr.children[idx]
        ptr.isEnd = True

    dp = defaultdict(lambda: defaultdict(lambda: False))

    def check(head, i, j):
        ptr = head
        N = j
        I = i
        while I < N:
            idx = getASCII(s[I])
            if not ptr.children[idx]:
                break
            while ptr.children[idx]:
                dp[i][I] = True
                I += 1
                if I >= N:
                    dp[i][I] = False
                    break
                ptr = ptr.children[idx]
                idx = getASCII(s[I])

    # O(N^2) each Trie search call will be O(N) hence O(N^2)
    for i in range(n):
        check(head, i, n)

    # I will now have all substrings that are possible

    @cache
    def recurr(i, j):
        if i >= n or j >= n or i > j:
            return 0
        final = float('inf')

        for k in range(i, j + 1):
            if dp[i][k]:
                final = min(final, 1 + recurr(k + 1, j))
        return final

    # O(N ^ 2)
    ans = recurr(0, n - 1)
    if ans == float('inf'):
        print(-1)
    else:
        print(ans)
# <-------------------------- END -------------------------->


solve()

def solve(n, l, s):
    lo = 1
    hi = n

    def helper(i):
        one = i * (i+1) >> 1
        two = 0
        if i - l > 0:
            two = (i-l)*(i-l+1) >> 1
        return one - two
    for _ in range(100):
        mid = ((hi - lo) >> 1) + lo
        val = helper(mid)
        if abs(s - val) < 2:
            if lo == 1:
                if s - val >= 0:
                    return "YES"
            elif mid == n:
                if s - val <= 0:
                    return "YES"
            else:
                return "YES"
        if s > val:
            lo = mid + 1
        elif s < val:
            hi = mid - 1
    return "NO"


for _ in range(int(input())):
    n, l, s = map(int, input().split())

    print(solve(n, l, s))

# Author : iron_nicko
from collections import Counter, defaultdict, deque
from bisect import bisect_left, bisect_right
from functools import cache
from itertools import accumulate
from heapq import heapify, heappush, heappop


def range_sum(l, r):
    l -= 1
    x = l * (l + 1) >> 1
    y = r * (r + 1) >> 1
    return y - x

def check(N, L, S, deletion=0):
    L += deletion
    l, r = 1,  N - L + 1
    while l <= r:
        mid = (l + r) >> 1
        subarray_sum = range_sum(mid, mid + L - 1)
        diff = subarray_sum - S
        if not deletion:
            if subarray_sum == S:
                return True
            elif subarray_sum < S:
                l = mid + 1
            else:
                r = mid - 1
        else:
            if diff < mid:
                l = mid + 1
            elif mid <= diff <= mid + L - 1:
                return True
            else:
                r = mid - 1
    return False


def solve():
    N, L, S = map(int, input().split())
    print("NYOE S"[check(N, L, S, 1) or check(N, L, S) :: 2].rstrip())

for _ in range(int(input())):
    solve()