In the army, it isn't easy to form a group of soldiers that will be effective on the battlefield. The communication is crucial and thus no two soldiers should share a name (what would happen if they got an order that Bob is a scouter, if there are two Bobs?).

A group of soldiers is effective if and only if their names are different. For example, a group (John, Bob, Limak) would be effective, while groups (Gary, Bob, Gary) and (Alice, Alice) wouldn't.

You are a spy in the enemy's camp. You noticed n soldiers standing in a row, numbered 1 through n. The general wants to choose a group of k consecutive soldiers. For every k consecutive soldiers, the general wrote down whether they would be an effective group or not.

You managed to steal the general's notes, with n - k + 1 strings s1, s2, ..., sn - k + 1, each either "YES" or "NO". 

  * The string s1 describes a group of soldiers 1 through k ("YES" if the group is effective, and "NO" otherwise). 
  * The string s2 describes a group of soldiers 2 through k + 1. 
  * And so on, till the string sn - k + 1 that describes a group of soldiers n - k + 1 through n. 



Your task is to find possible names of n soldiers. Names should match the stolen notes. Each name should be a string that consists of between 1 and 10 English letters, inclusive. The first letter should be uppercase, and all other letters should be lowercase. Names don't have to be existing names — it's allowed to print "Xyzzzdj" or "T" for example.

Find and print any solution. It can be proved that there always exists at least one solution.

Input

The first line of the input contains two integers n and k (2 ≤ k ≤ n ≤ 50) — the number of soldiers and the size of a group respectively.

The second line contains n - k + 1 strings s1, s2, ..., sn - k + 1. The string si is "YES" if the group of soldiers i through i + k - 1 is effective, and "NO" otherwise.

Output

Find any solution satisfying all given conditions. In one line print n space-separated strings, denoting possible names of soldiers in the order. The first letter of each name should be uppercase, while the other letters should be lowercase. Each name should contain English letters only and has length from 1 to 10.

If there are multiple valid solutions, print any of them.

Examples

Input

8 3
NO NO YES YES YES NO


Output

Adam Bob Bob Cpqepqwer Limak Adam Bob Adam

Input

9 8
YES NO


Output

R Q Ccccccccc Ccocc Ccc So Strong Samples Ccc

Input

3 2
NO NO


Output

Na Na Na

Note

In the first sample, there are 8 soldiers. For every 3 consecutive ones we know whether they would be an effective group. Let's analyze the provided sample output:

  * First three soldiers (i.e. Adam, Bob, Bob) wouldn't be an effective group because there are two Bobs. Indeed, the string s1 is "NO". 
  * Soldiers 2 through 4 (Bob, Bob, Cpqepqwer) wouldn't be effective either, and the string s2 is "NO". 
  * Soldiers 3 through 5 (Bob, Cpqepqwer, Limak) would be effective, and the string s3 is "YES". 
  * ..., 
  * Soldiers 6 through 8 (Adam, Bob, Adam) wouldn't be effective, and the string s6 is "NO".

Source: codeforces | Difficulty: MEDIUM
Tags: Greedy algorithms

Constructive algorithms


Solutions:
import sys
import math
from math import *
import builtins
import collections
import bisect
import os
from io import BytesIO, IOBase

def print(x, end='\n'):
	sys.stdout.write(str(x) + end)

def get_int():
	return int(input())

def get_list_ints():
	return list(map(int, input().split()))

def get_char_list():
	s = input()
	return list(s[:len(s) - 1])

def get_tuple_ints():
	return tuple(map(int, input().split()))

def print_iterable(p):
	print(' '.join(map(str, p)))

def CountFrequency(arr):
	return collections.Counter(arr)

def reverse(s):
	l = len(s)
	for i in range(l // 2):
		(s[i], s[l - i - 1]) = (s[l - i - 1], s[i])
	return s

def binary_search(arr, x):
	low = 0
	high = len(arr) - 1
	mid = 0
	while low <= high:
		mid = (high + low) // 2
		if arr[mid] < x:
			low = mid + 1
		elif arr[mid] > x:
			high = mid - 1
		else:
			return mid
	return high

def lower_bound(arr, x):
	return bisect.bisect_left(arr, x, lo=0, hi=len(arr))

def upper_bound(arr, x):
	return bisect.bisect_right(arr, x, lo=0, hi=len(arr))

def pow(a, n):
	if n == 0:
		return 1
	elif n % 2 == 0:
		return pow(a, n // 2) % const * (pow(a, n // 2) % const) % const
	else:
		return pow(a, n // 2) % const * (pow(a, n // 2) % const) * (a % const) % const

def main():
	[n, k] = get_list_ints()
	list = ['Aa', 'Ab', 'Ac', 'Ad', 'Ae', 'Af', 'Ag', 'Ah', 'Ai', 'Aj', 'Ak', 'Al', 'Am', 'An', 'Ao', 'Ap', 'Aq', 'Ar', 'As', 'At', 'Au', 'Av', 'Aw', 'Ax', 'Ay', 'Az', 'Ba', 'Bb', 'Bc', 'Bd', 'Be', 'Bf', 'Bg', 'Bh', 'Bi', 'Bj', 'Bk', 'Bl', 'Bm', 'Bn', 'Bo', 'Bp', 'Bq', 'Br', 'Bs', 'Bt', 'Bu', 'Bv', 'Bw', 'Bx', 'By', 'Bz']
	listi = [i for i in input().split()]
	lista = list[:k - 1]
	for j in range(n - k + 1):
		if listi[j] == 'NO':
			lista.append(lista[1 - k])
		else:
			lista.append(list[j + k - 1])
	print_iterable(lista)
	pass
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')
main()


names = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Aa', 'Ab', 'Ac', 'Ad', 'Ae', 'Af', 'Ag', 'Ah', 'Ai', 'Aj', 'Ak', 'Al', 'Am', 'An', 'Ao', 'Ap', 'Aq', 'Ar', 'As', 'At', 'Au', 'Av', 'Aw', 'Ax']
i = 0
(n, k) = list(map(int, input().split()))
arr = input().split()
ans = []
if arr[0] == 'NO':
	ans = names[:k - 1] + [names[0]]
	i = k
else:
	ans = names[:k]
	i = k
arr = arr[1:]
k = 0
for truth in arr:
	k += 1
	if truth == 'YES':
		ans += [names[i]]
		i += 1
	else:
		ans += [ans[k]]
print(' '.join(ans))


(n, k) = map(int, input().split())
s = input().split()
d = []
ans = [''] * n
cnt = 0
for i in range(26):
	for j in range(26):
		d.append(chr(i + ord('a')).upper() + chr(j + ord('a')))
		if i + j < n:
			ans[i + j] = chr(i + ord('a')).upper() + chr(j + ord('a'))
			cnt = i + j + 1
for i in range(len(s) - 1, -1, -1):
	if s[i] == 'NO':
		ans[i] = ans[i + k - 1]
print(' '.join(ans))


(n, k) = map(int, input().split())
l = []
for i in range(65, 91):
	l.append(chr(i))
for i in range(65, 91):
	l.append(chr(i) + chr(i + 32))
ans = l[:k - 1]
x = list(map(str, input().split()))
for i in range(n - k + 1):
	if x[i] == 'YES':
		for j in range(50):
			if l[j] not in ans[i:i + k]:
				ans.append(l[j])
				break
	else:
		ans.append(ans[i])
print(*ans)


(n, k) = map(int, input().split())
names = []

def getNext(a):
	if a[1] == 'z':
		return chr(ord(a[0]) + 1) + 'a'
	else:
		return a[0] + chr(ord(a[1]) + 1)
a = list(input().split())
for i in range(len(a)):
	a[i] = 1 if a[i] == 'YES' else 0
tmp = 'Aa'
names.append(tmp)
if a[0]:
	for i in range(k - 1):
		tmp = getNext(tmp)
		names.append(tmp)
else:
	names.append(tmp)
	for i in range(k - 2):
		tmp = getNext(tmp)
		names.append(getNext(tmp))
for i in range(k, n):
	if a[i - k + 1]:
		tmp = getNext(tmp)
		names.append(getNext(tmp))
	else:
		names.append(names[i - k + 1])
print(*names)


c = []
for i in range(65, 91):
	for j in range(97, 123):
		c.append(chr(i) + chr(j))
(n, k) = map(int, input().split())
l = list(map(str, input().split()))
z = 0
p = []
if l[0] == 'YES':
	p += c[z:z + k]
	z += k
else:
	p += c[z:z + k - 1]
	p += [c[z]]
	z += k - 1
for i in range(1, len(l)):
	if l[i] == 'YES':
		p += [c[z]]
		z += 1
	else:
		p += [p[len(p) - k + 1]]
print(*p)


count = 0

def new_name():
	global count
	if count < 26:
		r = 'A' + chr(ord('a') + count)
	else:
		r = 'B' + chr(ord('a') + count - 26)
	count += 1
	return r
(n, k) = map(int, input().split())
s = [s_i == 'YES' for s_i in input().split()]
names = [new_name() for i in range(k - 1)]
for s_i in s:
	if s_i:
		names.append(new_name())
	else:
		names.append(names[-(k - 1)])
print(' '.join(names))


alph = 'ABCDEFGHIJKLMNOPQRSTUWVXYZ'
names = [i + 'x' for i in alph] + [i + 'y' for i in alph]
(n, k) = map(int, input().split())
s = input().split()
sold = names[:k]
c = k
for i in s:
	if i == 'NO':
		sold[c - 1] = sold[c - k]
	sold.append(names[c])
	c += 1
print(*sold[:-1])


from sys import stdin, stdout

def ri():
	return map(int, input().split())
name1 = [i for i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ']
name2 = [i for i in 'abc']
name = []
for i in range(3):
	for j in range(26):
		name.append(name1[j] + name2[i])
(n, k) = ri()
na = list(input().split(' '))
ans = [i for i in range(n)]
for i in range(0, n - k + 1):
	if na[i] == 'NO':
		ans[i + k - 1] = ans[i]
print(' '.join([name[i] for i in ans]))


import random
(n, m) = map(int, input().split(' '))
s = input().split(' ')
ans = [i for i in range(n)]
for i in range(m):
	ans[i] = 'A'
	for j in range(i):
		ans[i] += 'a'
	if len(ans[i]) > 10:
		ans[i] = ans[i][:1] + chr(random.randrange(0, 25) + ord('a')) + chr(random.randrange(0, 25) + ord('a')) + chr(random.randrange(0, 25) + ord('a'))
if s[0] == 'NO':
	ans[m - 1] = ans[0]
id = m
j = 1
for i in range(m, n):
	if s[j] == 'NO':
		ans[i] = ans[i - m + 1]
	elif len(ans[i - 1]) <= 8:
		ans[i] = ans[i - 1] + chr(random.randrange(0, 25) + ord('a')) + chr(random.randrange(0, 25) + ord('a'))
	else:
		ans[i] = ans[i - 1]
		ans[i] = ans[i][:1] + chr(random.randrange(0, 25) + ord('a')) + chr(random.randrange(0, 25) + ord('a')) + chr(random.randrange(0, 25) + ord('a'))
	j += 1
for i in ans:
	print(i, end=' ')


(n, k) = [int(i) for i in input().split()]
s = [i for i in input().split()]
res = []
c1 = ord('A')
c2 = ord('a')
c3 = ord('a')
for i in range(0, k - 1):
	res1 = ''
	if c1 == ord('Z') and c2 == ord('z'):
		res1 = chr(c1) + chr(c2) + chr(c3)
		c3 += 1
	elif c1 == ord('Z'):
		res1 = chr(c1) + chr(c2)
		c2 += 1
	else:
		res1 = chr(c1)
		c1 += 1
	res.append(res1)
for i in range(len(s)):
	if s[i] == 'NO':
		res.append(res[i])
	else:
		res1 = ''
		if c1 == ord('Z') and c2 == ord('z'):
			res1 = chr(c1) + chr(c2) + chr(c3)
			c3 += 1
		elif c1 == ord('Z'):
			res1 = chr(c1) + chr(c2)
			c2 += 1
		else:
			res1 = chr(c1)
			c1 += 1
		res.append(res1)
for i in res:
	print(i, end=' ')


def parent(x):
	global color
	y = x
	while color[x] != x:
		x = color[x]
	while y != x:
		(color[y], y) = (x, color[y])
	return x

def union(x, y):
	global color
	x = parent(x)
	y = parent(y)
	if size[x] < size[y]:
		(x, y) = (y, x)
	color[y] = x
	size[x] += size[y]
(n, k) = map(int, input().split())
a = input().split()
res = list(range(n))
color = list(range(n))
size = [1] * n
for i in range(n - k + 1):
	if a[i] == 'NO':
		union(i, i + k - 1)
alph = ''.join((chr(i) for i in range(ord('a'), ord('z') + 1)))
names = [x + y for x in alph.upper() for y in alph]
print(*[names[x] for x in color])


l = ['Aa', 'Ab', 'Ac', 'Ad', 'Ae', 'Af', 'Ag', 'Ah', 'Ai', 'Aj', 'Ak', 'Al', 'Am', 'An', 'Ao', 'Ap', 'Aq', 'Ar', 'As', 'At', 'Au', 'Av', 'Aw', 'Ax', 'Ay', 'Az', 'Aaa', 'Abb', 'Acc', 'Add', 'Aee', 'Aff', 'Agg', 'Ahh', 'Aii', 'Ajj', 'Akk', 'All', 'Amm', 'Ann', 'Aoo', 'App', 'Aqq', 'Arr', 'Ass', 'Att', 'Auu', 'Avv', 'Aww', 'Axx', 'Ayy']
(n, k) = map(int, input().split())
li = list(map(str, input().split()))
lc = l[:n]
for i in range(len(li)):
	if li[i] == 'NO':
		lc[i + k - 1] = lc[i]
for i in lc:
	print(i, end=' ')


from collections import Counter, OrderedDict
from itertools import permutations as perm
from fractions import Fraction
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1000000000.0) + 7
inf = float('inf')
(n, k) = gil()
x = 0
name = []
for ch in 'AB':
	for c in 'abcdefghijklmnopqrstuvwxyz':
		name.append(ch + c)
ans = []
for i in range(k - 1):
	ans.append(name[x])
	x += 1
for ch in gl():
	if ch == 'YES':
		ans.append(name[x])
		x += 1
	else:
		ans.append(ans[-k + 1])
print(' '.join(ans))


(n, k) = map(int, input().split())
arr = input().split()
valids = (chr(i) + chr(j) for i in range(65, 91) for j in range(97, 99))
ans = []
val = 1
if arr[0][0] == 'Y':
	for i in range(k):
		ans.append(next(valids))
else:
	a = next(valids)
	ans.append(a)
	ans.append(a)
	for i in range(k - 2):
		ans.append(next(valids))
for i in arr[1:]:
	if i[0] == 'N':
		ans.append(ans[val])
	else:
		ans.append(next(valids))
	val += 1
print(' '.join(ans))


(n, k) = input().split()
b = input().split()
out = list(range(int(n)))

def intToName(i):
	letters = ord('Z') - ord('A') + 1
	res = ''
	first = True
	while True:
		(i, c) = divmod(i, letters)
		if first:
			res += chr(ord('A') + c)
		else:
			res += chr(ord('a') + c)
		if i == 0:
			return res
		else:
			i -= 1
		first = False
i = 0
while i <= int(n) - int(k):
	soldierFirst = i
	soldierLast = i + int(k) - 1
	if b[i] == 'NO':
		out[soldierLast] = out[soldierFirst]
	i += 1
for i in range(int(n) - 1):
	print(intToName(out[i]), end=' ')
print(intToName(out[int(n) - 1]))


import math, sys, itertools

def main():
	(n, k) = map(int, input().split())
	lst = input().split()
	d = []
	it = 0
	itd = 0
	for i in range(k):
		if it > 25:
			itd += 1
			it = 0
		d.append(chr(65 + itd) + chr(97 + it))
		it += 1
	ans = []
	for i in range(k - 1):
		ans.append(d.pop())
	for i in range(k - 1, n):
		if lst[i - (k - 1)] == 'NO':
			ans.append(ans[i - (k - 1)])
		else:
			ans.append(d.pop())
			d.append(ans[i - (k - 1)])
	for i in range(n):
		print(ans[i], end=' ')
	print()
main()


from collections import Counter
(n, k) = map(int, input().split())
arr = input().split()
ans = ['a' for _ in range(n)]
a = 'b'
for i in range(n - k + 1):
	if arr[i] == 'YES':
		for j in range(i, i + k):
			if ans[j] == 'a':
				ans[j] = str(a)
				if a == 'z':
					a = 'aa'
				elif len(a) == 1:
					a = chr(ord(a) + 1)
				else:
					a = a[0] + chr(ord(a[1]) + 1)
for i in range(n - k + 1):
	if arr[i] == 'NO':
		c = Counter(ans[i:i + k])
		for x in c:
			if c[x] >= 2:
				break
		else:
			x = i + k - 1
			y = i
			ans[x] = ans[y]
ans = ['A' + x for x in ans]
print(*ans)


from random import *
(n, k) = list(map(int, input().split()))
s = input().split()
soliders = ['' for i in range(n)]

def newname():
	name = chr(randint(65, 90))
	for i in range(9):
		name += chr(randint(97, 122))
	return name
if s[0] == 'NO':
	soliders[0] = newname()
	soliders[1] = soliders[0]
	for j in range(2, 2 + k):
		if j > n - 1:
			break
		soliders[j] = newname()
else:
	for j in range(0, k):
		soliders[j] = newname()
for i in range(1, n - k + 1):
	if s[i] == 'YES':
		soliders[i + k - 1] = newname()
	else:
		soliders[i + k - 1] = soliders[i]
print(*soliders)


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

def generate_name(n):
	s = ''
	for i in range(10):
		if n == 0:
			break
		for j in range(26):
			n -= 1
			if n == 0:
				s += chr(ord('A') + j)
				return s.title()
		s += 'Z'
	return s.title()
names = []
t = 1
for i in range(k - 1):
	names.append(generate_name(t))
	t += 1
for word in s:
	if word == 'YES':
		names.append(generate_name(t))
		t += 1
	else:
		names.append(names[-min(k - 1, len(names))])
print(' '.join(names))


(n, k) = map(int, input().split())
l = list(map(str, input().split()))
A = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Aa', 'Ab', 'Ac', 'Ad', 'Ae', 'Af', 'Ag', 'Ah', 'Ai', 'Aj', 'Ak', 'Al', 'Am', 'An', 'Ao', 'Ap', 'Aq', 'Ar', 'As', 'At', 'Au', 'Av', 'Aw', 'Ax', 'Ay', 'Az']
ans = []
for i in range(k - 1):
	ans.append(A[i])
temp1 = 0
temp2 = k - 1
for i in range(len(l)):
	if l[i] == 'YES':
		ans.append(A[temp2])
		temp2 += 1
	else:
		ans.append(ans[-k + 1])
print(*ans)


def ntoname(num):
	c = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
	l = 'abcdefghijklmnopqrstuvwxyz'
	na = c[num % 26]
	num //= 26
	while num:
		na += l[num % 26]
		num //= 26
	return na
(n, k) = map(int, input().split())
L = [True if i == 'YES' else False for i in input().split()]
ids = [i for i in range(n)]
for i in range(len(L)):
	if not L[i]:
		ids[i + k - 1] = ids[i]
print(*map(ntoname, ids))


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		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 = self.os.read(self._fd, max(self.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 = self.os.read(self._fd, max(self.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:
			self.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 collections import defaultdict as dd, deque as dq, Counter as dc
import math, string

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def getMat(n):
	return [getInts() for _ in range(n)]
MOD = 10 ** 9 + 7

def solve():
	poss = [chr(ord('a') + j).upper() for j in range(26)]
	poss2 = ['A' + x.lower() for x in poss]
	names = poss + poss2
	(N, K) = getInts()
	S = getStrs()
	ans = [names[j] for j in range(K - 1)]
	curr = K - 1
	for i in range(K - 1, N):
		if S[i - K + 1] == 'NO':
			ans.append(ans[i - K + 1])
		else:
			ans.append(names[curr])
			curr += 1
	print(*ans)
	return
solve()


numsLine = input()
numsLine = numsLine.split()
k = int(numsLine[0])
n = int(numsLine[1])
seq = input()
seq = seq.split()
dic = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Aa', 'Ba', 'Ca', 'Da', 'Ea', 'Fa', 'Ga', 'Ha', 'Ia', 'Ja', 'Ka', 'La', 'Ma', 'Na', 'Oa', 'Pa', 'Qa', 'Ra', 'Sa', 'Ta', 'Ua', 'Va', 'Wa', 'Xa']
names = []
for i in range(k):
	names.append(dic[i])
base = 100
for i in range(len(seq)):
	if seq[i] == 'YES':
		base = i
		break
if base == 100:
	for i in range(1, k):
		names[i] = names[0]
else:
	for i in range(base + 1, len(seq)):
		if seq[i] == 'NO':
			names[n - 1 + i] = names[i]
	for i in range(0, base):
		names[i] = names[base]
print(' '.join(names))


names = list('A B C D E F G H I J K L M N O P Q R S T U V W X Y Z Ab Bb Cb Db Eb Fb Gb Hb Ib Jb Kb Lb Mb Nb Ob Pb Qb Rb Sb Tb Ub Vb Wb Xb Gh Rg Df'.split())
(n, k) = map(int, input().split())
A = list(input().split())
find = False
ans = [0] * n
for i in range(n - k + 1):
	s = A[i]
	if find:
		if s == 'YES':
			c = 0
			while names[c] in ans[i:]:
				c += 1
			ans[i + k - 1] = names[c]
		else:
			ans[i + k - 1] = ans[i]
	elif s == 'NO':
		ans[i] = names[0]
	else:
		now = i
		for j in range(k):
			ans[now] = names[j]
			now += 1
		find = True
if not find:
	for i in range(n - k + 1, n):
		ans[i] = names[0]
print(' '.join(ans))


line = input()
(troop_count, groups) = line.split()
(troop_count, groups) = (int(troop_count), int(groups))
line = input()
a = line.split()
names = []
name = 'A'
place = 0
for (index, i) in enumerate(a):
	if i == 'YES' and index == 0:
		for b in range(groups):
			names.append(name)
			name = name + 'a'
			place = place + 1
	elif i == 'YES':
		names.append(name)
		name = name + 'a'
		place = place + 1
	elif i == 'NO' and index == 0:
		for j in range(groups):
			names.append(name)
			name = name + 'a'
			place = place + 1
		names[groups - 1] = names[0]
	else:
		names.append(names[place - groups + 1])
		place = place + 1
real_names = []
for i in names:
	a_count = i.count('a')
	temp_name = i
	if a_count > 45:
		temp_name = temp_name[0:-45]
		temp_name = temp_name + 'j'
	elif a_count > 40:
		temp_name = temp_name[0:-40]
		temp_name = temp_name + 'i'
	elif a_count > 35:
		temp_name = temp_name[0:-35]
		temp_name = temp_name + 'h'
	elif a_count > 30:
		temp_name = temp_name[0:-30]
		temp_name = temp_name + 'g'
	elif a_count > 25:
		temp_name = temp_name[0:-25]
		temp_name = temp_name + 'f'
	elif a_count > 20:
		temp_name = temp_name[0:-20]
		temp_name = temp_name + 'e'
	elif a_count > 15:
		temp_name = temp_name[0:-15]
		temp_name = temp_name + 'd'
	elif a_count > 10:
		temp_name = temp_name[0:-10]
		temp_name = temp_name + 'c'
	elif a_count > 4:
		temp_name = temp_name[0:-4]
		temp_name = temp_name + 'b'
	real_names.append(temp_name)
answer = ''
for i in real_names:
	answer = answer + i + ' '
answer = answer[0:-1]
print(answer)


def name(n):
	res = ''
	n += 1
	while n > 0:
		k = n % 26
		n //= 26
		res += l(k) if res else ll(k)
	return res

def l(n):
	return chr(ord('a') + n)

def ll(n):
	return chr(ord('A') + n)
(n, k) = map(int, input().split(' '))
L = input().split(' ')
L = [x == 'YES' for x in L]
res = []
i = 0
if L[0]:
	res = [name(i) for i in range(k)]
else:
	res = [name(0)] + [name(i) for i in range(k - 1)]
i = k
for b in L[1:]:
	if b:
		i += 1
		res.append(name(i))
	else:
		res.append(res[-k + 1])
print(' '.join(res))


names = [i for i in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'] + ['AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'[i:i + 2] for i in range(0, len('AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz'), 2)]
(n, k) = map(int, input().split())
yes_no = input().split()
guess = names[:n]
for i in range(len(yes_no)):
	if yes_no[i] == 'NO':
		guess[i + k - 1] = guess[i]
print(' '.join(guess))


names = [chr(ord('A') + i) for i in range(26)]
names += ['A' + chr(ord('a') + i) for i in range(26)]
(n, k) = map(int, input().split())
a = input().split()
for (i, a_i) in enumerate(a):
	if a_i == 'NO':
		names[i + k - 1] = names[i]
print(' '.join(names[:n]))


from io import BytesIO, IOBase
from math import sqrt
import sys, os
from os import path
inpl = lambda : list(map(int, input().split()))
inpm = lambda : map(int, input().split())
inpi = lambda : int(input())
inp = lambda : input()
(rev, ra, l) = (reversed, range, len)
P = print
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def B(n):
	return bin(n).replace('0b', '')

def factors(n):
	arr = []
	for i in ra(2, int(sqrt(n)) + 1):
		if n % i == 0:
			arr.append(i)
			if i * i != n:
				arr.append(int(n / i))
	return arr

def dfs(arr, n):
	pairs = [[i + 1] for i in ra(n)]
	vis = [0] * (n + 1)
	for i in ra(l(arr)):
		pairs[arr[i][0] - 1].append(arr[i][1])
	pairs[arr[i][1] - 1].append(arr[i][0])
	comp = []
	for i in ra(n):
		stack = [pairs[i]]
		temp = []
		if vis[stack[-1][0]] == 0:
			while len(stack) > 0:
				if vis[stack[-1][0]] == 0:
					temp.append(stack[-1][0])
					vis[stack[-1][0]] = 1
					s = stack.pop()
					for j in s[1:]:
						if vis[j] == 0:
							stack.append(pairs[j - 1])
				else:
					stack.pop()
			comp.append(temp)
	return comp
from bisect import bisect_left as bl
from bisect import bisect_right as br
import sys, operator, math, operator
from collections import Counter
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
import random
(n, k) = inpm()
li = input().split()
le = len(li)
arr = [0] * 51
c = 65
ans = [0] * n
for i in ra(1, 27):
	arr[i] = chr(c)
	c += 1
c = 65
for i in ra(27, 51):
	arr[i] = chr(c) + chr(97)
	c += 1
for i in ra(le):
	if li[i] == 'NO':
		li[i] = 0
	else:
		li[i] = 1
if li[0] == 0:
	ans[0] = 1
	for i in ra(1, k):
		ans[i] = i
else:
	for i in ra(k):
		ans[i] = i + 1
for i in ra(1, le):
	if li[i] == 0:
		ans[i + k - 1] = ans[i]
	else:
		for j in ra(1, 51):
			if j not in ans[i:i + k - 1]:
				ans[i + k - 1] = j
				break
for i in ra(n):
	P(arr[ans[i]], end=' ')


(n, k) = map(int, input().split())
effective = input().split()
array = list()
values = list()
lower_case = 'abcdefghijklmnopqrstuvwxyz'
upper_case = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(2):
	for j in range(26):
		if i != j:
			value = upper_case[i] + lower_case[j]
			values.append(value)
for i in range(n):
	array.append(values[i])
for i in range(n - k + 1):
	if effective[i] == 'NO':
		array[i + k - 1] = array[i]
for i in range(n):
	print('%s ' % array[i], end='')
print()


(n, k) = map(int, input().split())
a = list(input().split())
now = k + 5
res = [0] * n
for i in range(k - 1):
	res[i] = i + 1
for i in range(k - 1, n):
	if i == k - 1 and a[0] == 'YES':
		res[i] = k
		continue
	if a[i - k + 1] == 'YES':
		res[i] = now
		now += 1
	else:
		res[i] = res[i - k + 1]
alphabet = 'abcdefghijklmnop'
balphabet = 'ABCDEFGHIJKLMNOP'
for i in range(n):
	print(balphabet[res[i] // 10] + alphabet[res[i] % 10], end=' ')


(n, k) = map(int, input().split())
a = input().split()
uq_names = [chr(i) for i in range(ord('A'), ord('Z') + 1)]
uq_names += [s + 'a' for s in uq_names]
res = uq_names[:k - 1]
uni = k - 1
for (i, b) in enumerate(a):
	if b == 'YES':
		res.append(uq_names[uni])
		uni += 1
	else:
		res.append(res[i])
print(' '.join(res))


(n, k) = map(int, input().split())
good = [False] * 50
ans = [-1] * 50

def name(val):
	s = chr(65 + val % 26) + chr(97 + val // 26)
	return s
s = input().split(' ')
for i in range(n - k + 1):
	if s[i] == 'YES':
		good[i] = True
for i in range(0, k - 1):
	ans[i] = i
for i in range(k - 1, n):
	if good[i - k + 1]:
		ans[i] = i
	else:
		ans[i] = ans[i - k + 1]
for i in range(n):
	print(name(ans[i]), end=' ')


(n, k) = map(int, input().split())
words = []
for i in range(ord('A'), ord('Z') + 1):
	for j in range(ord('a'), ord('z') + 1):
		words.append(chr(i) + chr(j))
our = input().split()
res = [i for i in range(n)]
for j in range(50):
	for i in range(len(our)):
		if our[i] == 'NO':
			res[i] = res[i + k - 1]
for elem in res:
	print(words[elem], end=' ')


from sys import stdin
(n, k) = [int(x) for x in input().split()]
a = [x for x in stdin.readline().split()]
name = 'A'
names = []
for i in range(n + 1):
	names.append(name)
	if name == 'Z':
		name = 'Aa'
	elif len(name) == 1:
		name = chr(ord(name) + 1)
	elif len(name) == 2:
		name = name[0] + chr(ord(name[1]) + 1)
ans = []
nn = 0
if a[0] == 'YES':
	for i in range(k):
		ans.append(names[i])
	nn = k
else:
	ans = [names[0], names[0]]
	nn = k - 1
	for i in range(1, k - 1):
		ans.append(names[i])
for i in range(1, n - k + 1):
	if a[i] == 'YES':
		ans.append(names[nn])
		nn += 1
	else:
		ans.append(ans[i])
print(' '.join(ans))


(n, k) = map(int, input().split())
sld = input().split()
ls = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
names = [str(ls[i // len(ls)]).upper() + ls[i % len(ls)] for i in range(55)]
cur = k
ans = names[:k - 1]
for s in sld:
	if s == 'NO':
		ans.append(ans[-(k - 1)])
	else:
		ans.append(names[cur])
		cur += 1
print(*ans)


import string
(n, k) = list(map(int, input().split()))
conds = list(map(str, input().split()))
names = list()
for i in range(n):
	names.append(string.ascii_uppercase[i % 26] + string.ascii_lowercase[i // 26])
for j in range(n - k + 1):
	if conds[j] == 'YES':
		pass
	else:
		names[j + k - 1] = names[j]
print(*names)


(n, k) = map(int, input().split())
a = input().split()
l = []
for i in range(n):
	if i < 26:
		l.append(chr(i + 65))
	else:
		l.append('A' + chr(i - 26 + 97))
for i in range(n - k + 1):
	if a[i] == 'NO':
		l[i + k - 1] = l[i]
print(*l)


def main():
	(n, k) = map(int, input().split())
	res = ['AB'[i // 26] + chr(97 + i % 26) for i in range(n)]
	for (i, w) in enumerate(input().split()):
		if w == 'NO':
			res[i + k - 1] = res[i]
	print(*res)
main()


name = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Aa', 'Ba', 'Ca', 'Da', 'Ea', 'Fa', 'Ga', 'Ha', 'Ia', 'Ja', 'Ka', 'La', 'Ma', 'Na', 'Oa', 'Pa', 'Qa', 'Ra', 'Sa', 'Ta', 'Ua', 'Va', 'Wa', 'Xa', 'Ya', 'Za']
(n, k) = map(int, input().split())
a = list(map(str, input().split()))
l = [name[i] for i in range(k - 1)]
ans = [name[i] for i in range(k - 1)]
j = k - 1
o = k - 1
for i in range(n - k + 1):
	x = l.pop(0)
	l.append(name[o])
	o += 1
	if a[i] == 'YES':
		ans.append(name[j])
		j += 1
	else:
		ans.append(ans[len(ans) - k + 1])
print(*ans)


(n, k) = map(int, input().split())
a = list(input().split())
mem = []
mem2 = []
for i in 'abcdefghijklmnopqrstuvwxyz':
	mem.append(i)
	mem.append('a' + i)
	mem2.append('b' + i)
	mem2.append('c' + i)
dp = [-1] * n
c = 0
c2 = 0
for i in range(len(a)):
	if a[i] == 'NO':
		if dp[i] == -1:
			dp[i] = mem2[c2]
			dp[i + k - 1] = mem2[c2]
		else:
			dp[i + k - 1] = dp[i]
		c2 += 1
	else:
		for j in range(i, i + k):
			if dp[j] == -1:
				dp[j] = mem[c]
				c += 1
for i in range(n):
	if dp[i] == -1:
		dp[i] = 'a'
for i in dp:
	print(i[0].upper() + i[1:], end=' ')


class CodeforcesTask771BSolution:

	def __init__(self):
		self.result = ''
		self.n_k = []
		self.notes = []

	def read_input(self):
		self.n_k = [int(x) for x in input().split(' ')]
		self.notes = input().split(' ')

	def process_task(self):
		names = [0] * self.n_k[0]
		for x in range(self.n_k[0] - self.n_k[1] + 1):
			if self.notes[x] == 'NO':
				if not names[x]:
					names[x] = x + 1
					names[x + self.n_k[1] - 1] = x + 1
				else:
					names[x + self.n_k[1] - 1] = names[x]
		nn = max(names) + 1
		for x in range(len(names)):
			if not names[x]:
				names[x] = nn
				nn += 1
		nn -= 1
		tna = [chr(ord('A') + x) for x in range(26)] + [chr(ord('A') + x) + chr(ord('a') + x) for x in range(26)] + [chr(ord('A') + x) + chr(ord('a') + x) * 2 for x in range(26)]
		self.result = ' '.join([tna[x] for x in names])

	def get_result(self):
		return self.result
Solution = CodeforcesTask771BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(n, k) = map(int, input().split())
a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
names = []
for x in a:
	names.append(x)
	names.append(x + x.lower())
names = names[:n]
s = input().split()
for i in range(n - k + 1):
	if s[i] == 'NO':
		names[i + k - 1] = names[i]
print(' '.join(names))


LATIN = [chr(x) for x in range(ord('A'), ord('Z') + 1, 1)]
NAMES = [x + 'x' for x in LATIN] + [x + 'y' for x in LATIN]

def main():
	(n, k) = map(int, input().split())
	code = input().split()
	soldiers = NAMES[:k]
	i = k
	for c in code:
		if c == 'NO':
			soldiers[i - 1] = soldiers[i - k]
		soldiers.append(NAMES[i])
		i += 1
	print(' '.join(soldiers[:-1]))
main()


(n, k) = map(int, input().split())
names = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Aa', 'Bb', 'Cc', 'Dd', 'Ee', 'Ff', 'Gg', 'Hh', 'Ii', 'Jj', 'Kk', 'Ll', 'Mm', 'Nn', 'Oo', 'Pp', 'Qq', 'Rr', 'Ss', 'Tt', 'Uu', 'Vv', 'Ww', 'Xx', 'Yy', 'Zz']
e = input().split()
names = names[:n]
for i in range(n - k + 1):
	if e[i] == 'NO':
		names[i + k - 1] = names[i]
ans = ' '.join(names)
print(ans)


(n, k) = map(int, input().split())
ip = list(input().split())
arr = [0 for i in range(n)]
o = ord('A')
for i in range(n):
	if o <= 90:
		arr[i] = chr(o)
		o += 1
	else:
		arr[i] = 'A' + chr(o + 6)
		o += 1
for i in range(len(ip)):
	if ip[i] == 'NO':
		arr[i + k - 1] = arr[i]
for i in arr:
	print(i, end=' ')


(n, k) = map(int, input().split())
p = input().split()
w = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
q = [str(w[i // len(w)]).upper() + w[i % len(w)] for i in range(55)]
o = k
r = q[:k - 1]
for s in p:
	if s == 'NO':
		r.append(r[-(k - 1)])
	else:
		r.append(q[o])
		o += 1
print(*r)


(n, k) = map(int, input().split())
a = input().split()
names = [chr(ord('A') + i) for i in range(26)] + [chr(ord('A') + i) + chr(ord('a') + i) for i in range(26)]
ans = [names[i] for i in range(n)]
for i in range(k - 1, n):
	if a[i - k + 1] == 'NO':
		ans[i] = ans[i - k + 1]
print(*ans)


(n, k) = map(int, input().split())
possible_names = [a + b for a in 'QWERTYUIOPLKJHGFDSAZXCVBNM' for b in 'qwertyuioplkjhgfdsazxcvbnm']
names = [possible_names.pop() for i in range(k - 1)]
for word in input().split():
	if word == 'YES':
		names.append(possible_names.pop())
	else:
		names.append(names[-k + 1])
print(*names)


(n, k) = map(int, input().split())
names = []
for i in range(ord('a'), ord('z') + 1):
	names.append('A' + chr(i))
for i in range(ord('a'), ord('z') + 1):
	names.append('B' + chr(i))
pos = 0
a = input().split()
ans = []
for i in range(k - 1):
	ans.append(names[pos])
	pos += 1
for i in range(n - k + 1):
	if a[i] == 'YES':
		ans.append(names[pos])
		pos += 1
	else:
		ans.append(ans[i])
print(' '.join(ans))


(n, k) = map(int, input().split())
s = [i == 'YES' for i in input().split()]
r = []
name = 'Aa'

def nextName():
	global name
	if name[-1] == 'z':
		name = name + 'a'
	else:
		name = name[:-1] + chr(ord(name[-1]) + 1)
	return name
for i in range(k - 1):
	r.append(nextName())
for i in range(n - k + 1):
	r.append(nextName() if s[i] else r[i])
print(*r)


(n, k) = map(int, input().split())
s = input().split()
ans = []
for i in range(26):
	ans.append(chr(65 + i) + 'a')
for i in range(24):
	ans.append(chr(65 + i) + 'b')
for i in range(n - k + 1):
	if s[i] == 'NO':
		ans[i + k - 1] = ans[i]
ans = ans[:n]
print(*ans)


(n, k) = map(int, input().split())
answers = input().split()
names = []
army = []
for i in range(26):
	names.append('Aa' + chr(ord('a') + i))
for i in range(24):
	names.append('Ab' + chr(ord('a') + i))
for i in range(n - k + 1):
	if answers[i] == 'NO':
		names[i + k - 1] = names[i]
names = names[:n]
print(' '.join(names))


from string import ascii_lowercase
import collections
(n, m) = map(int, input().split())
l = list(input().split())
answer = collections.deque()
Names = []
(start, end) = (0, m - 1)
for i in ascii_lowercase.upper():
	for j in ascii_lowercase:
		Names.append(i + j)
for i in range(0, m - 1):
	print(Names[i], end=' ')
	answer.append(Names[i])
for i in l:
	if i == 'YES':
		answer.append(Names[end])
		end += 1
	else:
		answer.append(answer[0])
	answer.popleft()
	print(answer[-1], end=' ')


def main():
	s = ['' for _ in range(105)]
	(n, k) = list(map(int, str(input()).strip().split()))
	answers = list(map(str, str(input()).strip().split()))
	for i in range(1, n + 1):
		st = list('Aa')
		st[0] = chr(ord(st[0]) + i // 26)
		st[1] = chr(ord(st[1]) + i % 26)
		s[i] = ''.join(st)
	for start in range(n - k + 1):
		answer = answers[start]
		if answer == 'NO':
			s[start + k] = s[start + 1]
	for i in range(1, n + 1):
		print(s[i], end=' ')
main()


from collections import deque
from sys import stdin
import itertools
lines = deque((line.strip() for line in stdin.readlines()))

def nextline():
	return lines.popleft()

def types(cast):
	return tuple((int(x) for x in nextline().split()))

def ints():
	return types(int)

def strs():
	return nextline().split()

def name(i):
	n = ''
	while i >= 0:
		n += chr(ord('a') + i % 26)
		i = i // 26 - 1
	return n[::-1].title()

def main():
	(n, k) = ints()
	s = list(strs())
	if k == n:
		if s[0] == 'YES':
			names = []
			for i in range(k):
				names.append(name(i))
		else:
			names = ['A'] * n
	elif 'YES' not in s:
		names = ['A'] * n
	else:
		idx = s.index('YES')
		names = [''] * n
		for i in range(idx, idx + k):
			names[i] = name(i - idx)
		for i in range(idx - 1, -1, -1):
			if s[i] == 'YES':
				for j in range(k):
					nm = name(j)
					if nm not in names[i + 1:i + k]:
						names[i] = nm
						break
			else:
				names[i] = names[i + k - 1]
		for i in range(idx + 1, len(s)):
			if s[i] == 'YES':
				for j in range(k):
					nm = name(j)
					if nm not in names[i:i + k - 1]:
						names[i + k - 1] = nm
						break
			else:
				names[i + k - 1] = names[i]
	return names
print(' '.join(main()))


(n, k) = map(int, input().split())
s = input().split()
a = [''] * n
z = 'A'
c = 'a'
for i in range(n):
	a[i] = z + c
	if c == 'z':
		z += 'a'
		c = 'a'
	else:
		c = chr(ord(c) + 1)
for i in range(n - k + 1):
	if s[i] == 'NO':
		a[i + k - 1] = a[i]
print(*a)


(n, k) = map(int, input().split())
l_o = input().split()
a_n = ['A']
for i in range(1, n):
	diff = i - 25 if i >= 25 else 0
	a_n += [chr(ord('A') + i - (26 if diff != 0 else 0)) + ('' if diff == 0 else chr(ord('a') + diff))]
for i in range(n - k + 1):
	if l_o[i] == 'NO':
		a_n[i + k - 1] = a_n[i]
print(' '.join(a_n))


def generate():
	global t
	t += 1
	k = t
	s = []
	while k:
		if k <= 26:
			s.append(chr(96 + k))
			k = 0
		else:
			s.append('z')
			k -= 26
	return ''.join(s)
(n, k) = map(int, input().split())
arr = input().split()
t = 0
F = [0] * n
for i in range(k):
	F[i] = generate()
if arr[0] == 'NO':
	F[k - 1] = F[0]
for i in range(1, n - k + 1):
	if arr[i] == 'YES':
		F[i + k - 1] = generate()
	else:
		F[i + k - 1] = F[i]
for i in range(n):
	F[i] = chr(ord(F[i][0]) - 32) + F[i][1:]
print(' '.join(F))


from string import ascii_uppercase
(n, k) = map(int, input().split())
s = list(input().split())
names = []
for i in ascii_uppercase:
	names.append(i)
	names.append('A' + str(i).lower())
a = []
if s[0] == 'YES':
	for i in range(k):
		a.append(names[i])
elif s[0] == 'NO':
	for i in range(k - 1):
		a.append(names[i])
	a.append(names[0])
for j in range(1, len(s)):
	if s[j] == 'YES':
		a.append(names[k - 1 + j])
	else:
		a.append(a[j])
print(*a)


names = [chr(i + 65) + chr(j + 97) for i in range(26) for j in range(26)]
(n, m) = map(int, input().split())
ans = names[:m - 1]
j = m - 1
k = 0
for i in input().split():
	if i == 'YES':
		ans.append(names[j])
		j += 1
	else:
		ans.append(ans[k])
	k += 1
print(' '.join(ans))


import sys, queue
try:
	import dev_act_ffc429465ab634
	DEV = True
except:
	DEV = False

def log(*s):
	if DEV:
		print('LOG', *s)

class EJudge:

	def __init__(self, problem='default', reclim=1 << 30):
		self.problem = problem
		sys.setrecursionlimit(reclim)

	def use_files(self, infile='', outfile=''):
		if infile != '':
			self.infile = open(infile)
			sys.stdin = self.infile
		if infile != '':
			self.outfile = open(outfile, 'w')
			sys.stdout = self.outfile

	def use_bacs_files(self):
		self.use_files(self.problem + '.in', self.problem + '.out')

	def get_tl(self):
		while True:
			pass

	def get_ml(self):
		tmp = [[[5] * 100000 for _ in range(1000)]]
		while True:
			tmp.append([[5] * 100000 for _ in range(1000)])

	def get_re(self):
		s = (0,)[8]

	def get_wa(self, wstr='blablalblah'):
		for _ in range(3):
			print(wstr)
		exit()

class IntReader:

	def __init__(self):
		self.ost = queue.Queue()

	def get(self):
		return int(self.sget())

	def sget(self):
		if self.ost.empty():
			for el in input().split():
				self.ost.put(el)
		return self.ost.get()

	def release(self):
		res = []
		while not self.ost.empty():
			res.append(self.ost.get())
		return res

def tokenized(s):
	word = []
	for ch in s.strip():
		if ch == ' ':
			if word:
				yield ''.join(word)
				word = []
		elif 'a' <= ch <= 'z' or 'A' <= ch <= 'Z' or '0' <= ch <= '9':
			word.append(ch)
		else:
			if word:
				yield ''.join(word)
				word = []
			yield ch
	if word:
		yield ''.join(word)
		word = []
ej = EJudge()
int_reader = IntReader()
fmap = lambda f, *l: list(map(f, *l))
parse_int = lambda : fmap(int, input().split())
(n, k) = parse_int()
seq = fmap(lambda x: x == 'YES', input().split())
names = [chr(ord('A') + i) for i in range(25)] + ['S' + chr(ord('a') + i) for i in range(25)]
names = names[:n]
for i in range(len(seq)):
	if not seq[i]:
		names[i + k - 1] = names[i]
print(' '.join(names))


def solve(n, k, a):
	t = 0
	ans = ['' for i in range(n)]
	i = 0
	while i < len(a) and a[i] == 'NO':
		ans[i] = names[0]
		i += 1
	if i == len(a):
		for j in range(i, i + k - 1):
			ans[j] = ans[0]
		return ans
	for j in range(i, i + k):
		ans[j] = names[t]
		t += 1
	while i < len(a):
		if a[i] == 'NO':
			ans[i + k - 1] = ans[i]
		else:
			ans[i + k - 1] = names[t]
			t += 1
		i += 1
	return ans
names = []
for i in range(ord('A'), ord('Z') + 1):
	for j in range(ord('a'), ord('z') + 1):
		names.append(chr(i) + chr(j))
(n, k) = list(map(int, input().strip().split()))
is_ok = input().strip().split()
ans = solve(n, k, is_ok)
print(*ans)


(n, k) = map(int, input().split())
v = ['AB'[i // 26] + 'abcdefghijklmnopqrstuvwxyz'[i % 26] for i in range(n)]
for (i, si) in enumerate(input().split()):
	if si == 'NO':
		v[i + k - 1] = v[i]
print(' '.join(v))


l = list(map(int, input().split()))
n = l[0]
m = l[1]
s = input().split()
p = []
for i in s:
	if i == 'NO':
		p.append(False)
	else:
		p.append(True)
l = []
for i in range(65, 91):
	for j in range(97, 121):
		for k in range(97, 121):
			l.append(chr(i) + chr(j) + chr(k))

def tek(l):
	for i in range(len(l)):
		for j in range(i + 1, len(l)):
			if l[i] == l[j]:
				return False
	return True
r = 1
q = []
for i in range(n + 1):
	q.append(l[r])
	r += 1
for i in range(n - m + 1):
	if tek(q[i:i + m]) != p[i]:
		if p[i]:
			o = q[i + 1:i + m + 1]
			for j in range(i + 1, i + m + 1):
				if o.count(q[j]) > 1:
					q[j] = l[r]
					o[j - i - 1] = l[r]
					r += 1
		else:
			q[i + m - 1] = q[i]
	if p[i] == False:
		q[i + m - 1] = q[i]
s = ''
del q[-1]
for i in q:
	s = s + ' ' + i
print(s[1:])


import string
(n, k) = [int(x) for x in str(input()).strip().split(' ', 1)]
dist = str(input()).strip().split(' ')
s = ['A' for _ in range(n + 1)]
s[0] = 'B'
q = s[:k + 1]
tot = k + 1
for i in range(1, k + 1):
	s[i] += string.ascii_lowercase[i % 26] * (i // 26 + 1)
for i in range(1, n - k + 2):
	if dist[i - 1] == 'YES':
		s[i + k - 1] = 'A' + string.ascii_lowercase[tot % 26] * (tot // 26 + 1)
		tot += 1
	else:
		s[i + k - 1] = s[i]
print(' '.join(s[1:]))


def get(x):
	return chr(ord('A') + x // 26) + chr(ord('a') + x % 26)
read = lambda : map(int, input().split())
(n, k) = read()
a = input().split()
ans = [0] * n
num = 1
for i in range(k - 1):
	ans[i] = num
	num += 1
for i in range(k - 1, n):
	cur = a[i - k + 1]
	if cur == 'YES':
		num += 1
		ans[i] = num
	else:
		ans[i] = ans[i - k + 1]
res = ' '.join(map(str, [get(i) for i in ans]))
print(res)


dic = {0: 'A', 1: 'B', 2: 'C', 3: 'D', 4: 'E', 5: 'F', 6: 'G', 7: 'H', 8: 'I', 9: 'J', 10: 'K', 11: 'L', 12: 'M', 13: 'N', 14: 'O', 15: 'P', 16: 'Q', 17: 'R', 18: 'S', 19: 'T', 20: 'U', 21: 'V', 22: 'W', 23: 'X', 24: 'Y', 25: 'Z', 26: 'Aa', 27: 'Ab', 28: 'Ac', 29: 'Ad', 30: 'Ae', 31: 'Af', 32: 'Ag', 33: 'Ah', 34: 'Ai', 35: 'Aj', 36: 'Ak', 37: 'Al', 38: 'Am', 39: 'An', 40: 'Ao', 41: 'Ap', 42: 'Aq', 43: 'Ar', 44: 'As', 45: 'At', 46: 'Au', 47: 'Av', 48: 'Aw', 49: 'Ax', 50: 'Ay', 51: 'Az'}
used = [False for i in range(52)]
(n, k) = [int(x) for x in input().split(' ')]
state = input().split(' ')
ans = [i for i in range(n)]
if state[0] == 'NO':
	ans[0] = 1
else:
	ans[0] = 0
for j in range(1, len(state)):
	st = state[j]
	if st == 'NO':
		ans[k + j - 1] = ans[j]
import sys
sys.stdout.write(dic[ans[0]])
for i in range(1, n):
	sys.stdout.write(' ' + dic[ans[i]])


import string
names = []
for t in range(9):
	for i in range(26):
		l = string.ascii_uppercase[i]
		names.append(l + (l * t).lower())
current = []
(n, k) = map(int, input().split())
stat = input().split()
if stat[0] == 'YES':
	for i in range(k):
		current.append(names[i])
else:
	current.append('A')
	for i in range(k - 2):
		current.append(names[i + 1])
	current.append('A')
counter = 1
for item in stat[1:]:
	if item == 'YES':
		current.append(names[counter + 100])
	else:
		current.append(current[counter])
	counter += 1
print(' '.join(current))


from sys import stdin, stdout
import string
(n, k) = map(int, stdin.readline().rstrip().split())
YesNoList = stdin.readline().rstrip().split()
nameList = list(string.ascii_uppercase) + ['A' + letter for letter in string.ascii_lowercase]
answerList = []
nl = 0
yn = 0
if YesNoList.count('YES') == 0:
	answerList = list('A' * n)
else:
	while YesNoList[yn] == 'NO':
		answerList.append(nameList[nl])
		yn += 1
	for _ in range(k):
		answerList.append(nameList[nl])
		nl += 1
	yn += 1
	nl -= 1
	while yn < n - k + 1:
		if YesNoList[yn] == 'YES':
			nl += 1
			answerList.append(nameList[nl])
		else:
			answerList.append(answerList[yn])
		yn += 1
print(' '.join(answerList))


MAS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']

def generateName(num):
	return MAS[num % 8] + MAS[int(num / 8)].lower()
(n, k) = [int(i) for i in input().split()]
mas = [i for i in input().split()]
names = [generateName(i) for i in range(n)]
for i in range(n - k + 1):
	if mas[i] == 'NO':
		names[i + k - 1] = names[i]
print(' '.join(names))


(n, k) = map(int, input().split())
arr = input().split()
cap = [chr(i + ord('A')) for i in range(26)]
sml = [chr(i + ord('a')) for i in range(26)]
res = []
for i in cap:
	for j in sml:
		res.append(i + j)
for i in range(n - k + 1):
	if arr[i] == 'NO':
		res[i + k - 1] = res[i]
print(*res[:n])


import sys
import math
from collections import Counter
from operator import itemgetter
import queue

def IO():
	sys.stdin = open('pyinput.txt', 'r')
	sys.stdout = open('pyoutput.txt', 'w')

def GCD(a, b):
	if b == 0:
		return a
	else:
		return GCD(b, a % b)

def LCM(a, b):
	return a * (b // GCD(a, b))

def scan(TYPE_1, TYPE_2=0):
	if TYPE_1 == int:
		return map(int, sys.stdin.readline().strip().split())
	elif TYPE_1 == float:
		return map(float, sys.stdin.readline().strip().split())
	elif TYPE_1 == list and TYPE_2 == float:
		return list(map(float, sys.stdin.readline().strip().split()))
	elif TYPE_1 == list and TYPE_2 == int:
		return list(map(int, sys.stdin.readline().strip().split()))
	elif TYPE_1 == str:
		return sys.stdin.readline().strip()
	else:
		print('ERROR!!!!')

def main():
	s = []
	for i in range(65, 91):
		s.append(chr(i))
	for i in range(97, 123):
		s.append('A' + chr(i))
	(n, k) = scan(int)
	a = scan(str).split()
	ans = []
	idx = 0
	for i in range(k - 1):
		ans.append(s[idx])
		idx += 1
	for i in range(n - k + 1):
		if a[i] == 'NO':
			ans.append(ans[-k + 1])
		else:
			ans.append(s[idx])
			idx += 1
	print(*ans)
main()


(n, k) = map(int, input().split())
names = []
pollU = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
pollL = 'abcdefghijklmnopqrstuvwxyz'
import random
for i in range(105):
	c = pollU[random.randint(1, 20)] + pollL[random.randint(1, 20)] + pollL[random.randint(1, 20)]
	while c not in names:
		c = pollU[random.randint(1, 20)] + pollL[random.randint(1, 20)] + pollL[random.randint(1, 20)] + pollL[random.randint(1, 20)]
		if c not in names and c[0].isupper():
			names.append(c)
m = list(input().split())
sol = []
j = k + 1
for i in range(len(m) - 1):
	if i == 0:
		if m[i] == 'NO':
			if m[i + 1] == 'YES':
				sol = [names[0]]
				for tt in range(k):
					sol.append(names[tt])
			else:
				sol = [names[0]]
				for tt in range(k - 1):
					sol.append(names[tt])
				sol += [sol[-k + 1]]
		elif m[i + 1] == 'YES':
			for tt in range(k):
				sol.append(names[tt])
			sol += [sol[0]]
		else:
			for tt in range(k):
				sol.append(names[tt])
			sol += [sol[-k + 1]]
	elif m[i + 1] == 'NO':
		sol += [sol[-k + 1]]
	else:
		sol += [names[j]]
		j += 1
if len(m) == 1:
	if m[0] == 'NO':
		for tt in range(k):
			sol.append(names[0])
	else:
		for tt in range(k):
			sol.append(names[tt])
print(*sol)


(n, k) = map(int, input().split())
s = input().split()
names = [chr(ord('A') + i // 26) + chr(ord('a') + i % 26) for i in range(1, n + 1)]
for i in range(len(s)):
	if s[i] == 'NO':
		names[i + k - 1] = names[i]
for name in names:
	print(name, end=' ')


import random

def random_str(rango, pos):
	while True:
		x = random.randint(65, 90)
		string = chr(x)
		x = random.randint(1, 10)
		for i in range(x - 1):
			rand = random.randint(97, 122)
			string += chr(rand)
		if string not in rango:
			break
	return string

def print_array(array):
	result = ''
	for string in array:
		result += string + ' '
	print(result)
(n, k) = map(int, input().strip().split(' '))
strings = input().strip().split(' ')
soldiers = [-1] * n
for i in range(n):
	soldiers[i] = random_str(soldiers, i)
pos = 0
for string in strings:
	if string == 'NO':
		aux = soldiers[pos]
		soldiers[pos + k - 1] = aux
	pos += 1
print_array(soldiers)


import sys

def main():
	names = []
	for i in range(26):
		s = 'A' + chr(ord('a') + i)
		s1 = 'X' + chr(ord('a') + i)
		names.append(s)
		names.append(s1)
	(n, k) = map(int, sys.stdin.readline().split())
	r = list(sys.stdin.readline().split())
	res = ['Ho'] * n
	cur = 0
	firstYes = -1
	for i in range(n - k + 1):
		if r[i] == 'YES':
			firstYes = i
			break
	if firstYes == -1:
		print(' '.join(res))
		return
	for i in range(firstYes + 1, firstYes + k):
		res[i] = names[cur]
		cur += 1
	for i in range(firstYes + 1, n - k + 1):
		if r[i] == 'YES':
			res[i + k - 1] = names[cur]
			cur += 1
		else:
			res[i + k - 1] = res[i]
	print(' '.join(res))
main()


def sToName(s):
	return 'A' + chr(s // 26 + ord('a')) + chr(s % 26 + ord('a'))
(n, k) = map(int, input().split())
a = list(map(lambda x: x == 'YES', input().split()))
d = [0] * n
s = -1
for i in range(k - 1):
	s += 1
	d[i] = s
for i in range(k - 1, n):
	if a[i - k + 1]:
		s += 1
		d[i] = s
	else:
		d[i] = d[i - k + 1]
print(*list(map(lambda x: sToName(x), d)))


(n, k) = map(int, input().split())
l = [True if x == 'YES' else False for x in input().split()]
res = list(range(k - 1))
for i in l:
	if i:
		for j in range(k):
			if j not in res[-k + 1:]:
				res.append(j)
				break
	else:
		res.append(res[-k + 1])
names = [chr(x) + chr(y) for x in range(ord('A'), ord('Z') + 1) for y in range(ord('a'), ord('z') + 1)]
for i in res:
	print(names[i], end=' ')
print()


def name(n):
	if n < 26:
		return chr(n + ord('A'))
	else:
		return chr(n - 26 + ord('A')) + 'a'
(n, k) = tuple(map(int, input().split()))
data = list(map(lambda x: x == 'YES', input().split()))
res = []
for i in range(k - 1):
	res.append(name(i))
for i in range(k - 1, n):
	if data[i - k + 1]:
		res.append(name(i))
	else:
		res.append(res[i - k + 1])
print(' '.join(res))


R = lambda : map(int, input().split())
(n, k) = R()
l = []
(s, s2) = (ord('A'), ord('a'))
for i in range(k):
	if i < 26:
		l.append(chr(s + i))
	else:
		l.append('A' + chr(s2 + i % 26))
	if i < k - 1:
		print(l[i], end=' ')
s = [i for i in range(k - 1)]
(i, j) = (k - 1, 0)
c = input().split()
for m in range(n - k + 1):
	if c[m] == 'YES':
		print(l[i], end=' ')
		s.append(i)
		i = s[j]
	else:
		print(l[s[j]], end=' ')
		s.append(s[j])
	j = j + 1


def name(n):
	return chr(ord('A') + n % 26) + chr(ord('a') + n // 26)

def main():
	(n, k) = map(int, input().split())
	arr = list(map(str, input().split()))
	if arr.count('YES') == 0:
		for i in range(n):
			print('Max ', end='')
		return
	ans = ['' for i in range(n)]
	x = arr.index('YES')
	for i in range(k):
		ans[x + i] = name(i + x)
	for i in range(x + 1, n - k + 1):
		if arr[i] == 'YES':
			ans[i + k - 1] = name(i + k - 1)
		else:
			ans[i + k - 1] = ans[i]
	for i in range(x - 1, -1, -1):
		if arr[i] == 'YES':
			ans[i] = name(i)
		else:
			ans[i] = ans[i + k - 1]
	print(*ans)
main()


(n, k) = map(int, input().split())
s = []
name = [''] * n
ptr = 0
yesno = []
for i in range(26):
	s.append(str(chr(65 + i)))
for i in range(26):
	s.append(str(chr(65 + i)) + 'a')

def f(x):
	global ptr
	global name
	for i in range(x, x + k):
		if name[i] == '':
			name[i] = s[ptr]
			ptr = ptr + 1
l = []
yesno = list(input().split())
for i in range(n - k + 1):
	if yesno[i] == 'YES':
		f(i)
for i in range(n - k + 1):
	if yesno[i] == 'NO' and i == 0:
		f(i)
		name[i] = name[i + 1]
	elif yesno[i] == 'NO':
		name[i + k - 1] = name[i]
for i in name:
	print(i, ' ', end='')


def get_data_from_line(line, convert_func=float):
	values = []
	temp_string = ''
	for char in line:
		if char in ['\t', ' ']:
			values.append(convert_func(temp_string))
			temp_string = ''
			char = ''
		if char == '\n':
			break
		temp_string += char
	values.append(convert_func(temp_string))
	return values

def convert_str(string):
	if string == 'YES':
		return 1
	else:
		return 0
first_line = input()
second_line = input()
first_line_val = get_data_from_line(first_line, int)
second_line_val = get_data_from_line(second_line, convert_str)
count_soldier = first_line_val[0]
group_size = first_line_val[1]
alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']

def get_unique_name(number):
	name = ''
	name += alphabet[int(number / 26)]
	name += alphabet[number % 26].lower()
	return name
i = 0
result = []
while i < group_size - 1:
	result.append(get_unique_name(i))
	i += 1
while i < count_soldier:
	if second_line_val[i + 1 - group_size] == 1:
		result.append(get_unique_name(i))
	else:
		result.append(result[i - group_size + 1])
	i += 1
print(result[0], end='')
for i in range(1, len(result)):
	print(' ' + result[i], end='')
print()


a = input().split(' ')
b = input().split(' ')
n = int(a[0])
k = int(a[1])

def gen_name(i):
	name = ''
	offset = ord('A')
	while i > 0:
		name += chr(i % 26 + offset)
		offset = ord('a')
		i //= 26
	if name == '':
		name = 'A'
	return name
ans = [gen_name(i) for i in range(n)]
for i in range(n - k + 1):
	if b[i] == 'NO':
		ans[i + k - 1] = ans[i]
print(' '.join(ans))