Well, the series which Stepan watched for a very long time, ended. In total, the series had n episodes. For each of them, Stepan remembers either that he definitely has watched it, or that he definitely hasn't watched it, or he is unsure, has he watched this episode or not. 

Stepan's dissatisfaction is the maximum number of consecutive series that Stepan did not watch.

Your task is to determine according to Stepan's memories if his dissatisfaction could be exactly equal to k.


-----Input-----

The first line contains two integers n and k (1 ≤ n ≤ 100, 0 ≤ k ≤ n) — the number of episodes in the series and the dissatisfaction which should be checked. 

The second line contains the sequence which consists of n symbols "Y", "N" and "?". If the i-th symbol equals "Y", Stepan remembers that he has watched the episode number i. If the i-th symbol equals "N", Stepan remembers that he hasn't watched the epizode number i. If the i-th symbol equals "?", Stepan doesn't exactly remember if he has watched the episode number i or not.


-----Output-----

If Stepan's dissatisfaction can be exactly equal to k, then print "YES" (without qoutes). Otherwise print "NO" (without qoutes).


-----Examples-----
Input
5 2
NYNNY

Output
YES

Input
6 1
????NN

Output
NO



-----Note-----

In the first test Stepan remembers about all the episodes whether he has watched them or not. His dissatisfaction is 2, because he hasn't watch two episodes in a row — the episode number 3 and the episode number 4. The answer is "YES", because k = 2.

In the second test k = 1, Stepan's dissatisfaction is greater than or equal to 2 (because he remembers that he hasn't watch at least two episodes in a row — number 5 and number 6), even if he has watched the episodes from the first to the fourth, inclusive.

Difficulty: interview

Starter code:

Solutions:
import sys

n, k = list(map(int, input().split(' ')))

s = input()

def max_streak(s):
    result = 0

    for i in range(len(s)):
        j = i
        while j < len(s) and s[j] == 'N':
            j += 1

        result = max(result, j - i)

    return result

for i in range(n - k + 1):
    cur = list(s)
    for j in range(i, i + k):
        if cur[j] == '?':
            cur[j] = 'N'

    for j in range(i):
        if cur[j] == '?':
            cur[j] = 'Y'

    for j in range(i + k, n):
        if cur[j] == '?':
            cur[j] = 'Y'

    if max_streak(cur) == k:
        print('YES')
        return

print('NO')


n, k = list(map(int, input().split()))
s = input()

cnt, mx = 0, 0

for i in range(n):
    if s[i] == "N":
        cnt += 1
    else:
        cnt = 0
    mx = max(mx, cnt)
    
if mx > k:
    print("NO\n")
    return

for r in range(k, n + 1):
    l = r - k
    if l > 0 and s[l - 1] == "N":
        continue
    if r < n and s[r] == "N":
        continue
    
    bad = False
    
    for i in range(l, r):
        if s[i] == "Y":
            bad = True
            break
        
    if not bad:
        print("YES\n")
        return

print("NO\n")


n, k = map(int, input().split())
k = int(k)
s = input()
s = "Y" + s + "Y"
res = "NO"
cnt = 0
can = True
for ch in s:
    if(ch == 'N'):
        cnt += 1
        if(cnt > k):
            can = False
    else:
        cnt = 0

for i in range(1,n+1):
    if(i + k - 2 < n):
        subs = s[i:i+k]
        # print(subs)
        flag = True
        for ch in subs:
            if(not ch in "N?"):
                flag = False
        if((s[i-1] in "Y?" and s[i+k] in "Y?") and flag):
            res = "YES"
            # print(s[i-1], subs, s[i+k])
if can:
    print(res)
else:
    print("NO")

n, k = list(map(int, input().split()))
s = list(input())
ans = False

for i in range(len(s) - k + 1):
    flag = True
    for j in range(i, i + k):
        if (s[j] == 'Y'):
            flag = False
            break
    if ((i + k) < len(s)) and s[i + k] == 'N': flag = False
    if (i > 0) and (s[i - 1] == 'N'): flag = False
    #print(i, flag)
    if (flag):
        ans = True
        break
    
maximum = 0
i = 0
while (i < len(s)):
    now = 0
    while (s[i] != 'N'):
        i += 1
        if (i >= len(s)):
            break
    if (i >= len(s)): break
    while (i < len(s)) and (s[i] == 'N'):
        i += 1
        now += 1
    maximum = max(maximum, now)
    
if ans and (maximum <= k):
    print('YES')
else: print('NO')


n, k = map(int, input().split())
string = input()
series = []
now = ""
for elem in string:
    if elem == "Y":
        if now:
            series.append(now)
        now = ""
    else:
        now += elem
if now:
    series.append(now)

answer = False
no_max = True
if not k:
    for elem in series:
        if elem.count('N'):
            answer = True
            
    print("YES" if not answer else "NO")
else:
    for elem in series:
        m = len(elem)
        for i in range(m - k + 1):
            if (not i or elem[i - 1] == '?') and ((i + k - 1) == m - 1 or elem[i + k] == '?'):
                answer = True
        
        counter = 0
        for letter in elem:
            if letter == 'N':
                counter += 1
                if counter > k:
                    no_max = False
            else:
                counter = 0
               
    print("YES" if answer and no_max else "NO")

n, m = list(map(int, input().split()))
s = input()
cnt = int(0)
for ch in s:
    if ch == 'N':
        cnt += 1
    elif cnt > m:
        print("NO")
        return;
    else:
        cnt = int(0)
if cnt > m:
    print("NO")
    return;
s = "Y"+s
for i in range(0, n+1):
    if s[i] == '?' or s[i] == 'Y':
        cnt = int(0)
        for j in range(i+1, n+1):
            #print(i, j, cnt, end = "\n")
            if s[j] == 'Y':
                if cnt == m:
                    print("YES")
                    return
                break
            if s[j] == '?':
                if cnt == m:
                    print("YES")
                    return
            cnt += 1
        if cnt == m:
            print("YES")
            return
print("NO")

from sys import stdin
from functools import lru_cache
from collections import defaultdict
infile = stdin
N, K = map(int, infile.readline().split())
watched = infile.readline().strip()

mem = set()
mem.add((0,0,0))
for i, letter in enumerate(watched):
    for d in range(K+1):
        for c in range(K+1):
            if (i,d,c) in mem:
                if letter in ('N', '?'):
                    mem.add((i+1, max(d, c+1), c+1))
                if letter in ('Y', '?'):
                    mem.add((i+1, d, 0))

def good():
    for i,d,c in mem:
        if i == N and d == K:
            return 'YES'
    return 'NO'


print(good())

# from Crypto.Util.number import *
# from Crypto.PublicKey import RSA
# from Crypto.Cipher import PKCS1_OAEP
#
#
# def gcd(a, b):
#     if a == 0:
#         return b, 0, 1
#     d, x1, y1 = gcd(b % a, a)
#     x = y1 - (b // a) * x1
#     y = x1
#     return d, x, y
#
#
# def find_private_key(p, q, e):
#     f = (p - 1) * (q - 1)
#     d = gcd(e, f)[1]
#     while d < 0:
#         d += f
#     return d
#
#
# n = 114603416258617277914112950886933842277017613048768896986887063295795075651032133331342538430388087616693581335924733790772692053706860660493046367184589390096319068611843480381499933909451620838321468620579057390519217231379164202675046840772638142625114303262708400933811096588213415014292281310788830121449
#
# q = 8931970881300680082796820734365022222452747937209215859340339248013322229502496422895802649243487560690551112016430906973314030768362034269763079075131391
#
# p = 12830697477814509540399242283518279629025340392811455061638565349197540239841408191167449256086467748949090279070442786996339222196995600246150833643209239
#
# e = 78078409585916972042386784533013985111341440946219174025831418904974306682701
#
# f = 114603416258617277914112950886933842277017613048768896986887063295795075651032133331342538430388087616693581335924733790772692053706860660493046367184589368333650709496653857185436916026149769360233138599908136411614620020516694858770432777520732812669804663621317314060117126934960449656657765396876111780820
#
# d = 95617909040393155444786936446642179824041050920013801086828472351343249663960737590719979187458429568264589317317553181803837347371438624774016758221657991995265788792118497392951947899512373618098318332328397239065334523447713343639400315086378757038001615086063906730779984567240713176171007926923058722581
#
# rsa = RSA.construct((n, e, d))
#
#
# #key = RSA.importKey(open('11.txt', 'r').read())
# key = RSA.importKey(open('public_key', 'r').read())
#
# print(key.__dict__)
#
# n = 5629218730419894595823026663331501597897818160771697280840122531313799328035654852733468829411876184951508514832506002593002170978628016095067716010208905588870963783855109137307480667920058731486899983319164243850148229252772614367640165351224879369373847162133237931086116505957707781534245331485441
# p = 2372597464893675257469711937093671629348264195072192501684944517176070474701064022851367306150417447503454422147341366642712704243329694637078892947639
# q = n // p
# e = 17
#
# d = find_private_key(p, q, e)
#
# encrypted = 1111861507760457047964156325933048837925622938918416900082721305322555941153755195985545404321101492441045781915244282849548935206776118071569007445626459132036648013508921232096378109573160336245447392600788211167388900011173139344891307651852665571685713133157519571136012382352182349879574471249590
# result = pow(encrypted, d, n)
#
# result = hex(result)[2:]
#
# ans = b''
# for i in range(0, len(result), 2):
#     ans += bytes([int(result[i:i+2], 16)])
#
# print(ans)
#
# return
#
# key = RSA.construct((n, e, d))
#
# with open('22.txt', 'wb') as fi:
#     fi.write(key.exportKey('PEM'))
#
# print('d =', d)





# import time
# import requests
#
# url = 'http://sql.training.hackerdom.ru/10lastlevel.php?text='
# condition = 'ORD(SUBSTRING(COLUMN_NAME, {}, 1)) = {}'
# query = "IF(ORD(SUBSTRING(chocolate, {}, 1)) = {}, SLEEP(1), 1) FROM davidblayne;"
# pos = 1
# sleep_time = 1
# a = {''}
#
# s = ''
# for i in range(1, 30):
#     for c in range(32, 128):
#         start = time.time()
#         requests.get(url + query.format(i, c))
#         end = time.time()
#
#         d = end - start
#
#         if d >= sleep_time:
#             print(chr(c))
#             s += chr(c)
#             break
#     else:
#         break
#
# print(s)

def calc(s):
    max_len = 0
    cur_len = 0
    for i in range(len(s)):
        if s[i] == 'N':
            cur_len += 1
        else:
            cur_len = 0
        max_len = max(max_len, cur_len)
    return max_len


n, k = list(map(int, input().split()))
s = input()

if calc(s) > k:
    print('NO')
    return

start = 0
while start + k - 1 < len(s):
    good = True
    for i in range(start, start + k):
        if s[i] == 'Y':
            good = False
            break
    if start - 1 >= 0 and s[start - 1] == 'N':
        good = False
    if start + k < len(s) and s[start + k] == 'N':
        good = False
    if good:
        print('YES')
        return
    start += 1

print('NO')