Innokentiy decides to change the password in the social net "Contact!", but he is too lazy to invent a new password by himself. That is why he needs your help. 

Innokentiy decides that new password should satisfy the following conditions:  the length of the password must be equal to n,  the password should consist only of lowercase Latin letters,  the number of distinct symbols in the password must be equal to k,  any two consecutive symbols in the password must be distinct. 

Your task is to help Innokentiy and to invent a new password which will satisfy all given conditions. 


-----Input-----

The first line contains two positive integers n and k (2 ≤ n ≤ 100, 2 ≤ k ≤ min(n, 26)) — the length of the password and the number of distinct symbols in it. 

Pay attention that a desired new password always exists.


-----Output-----

Print any password which satisfies all conditions given by Innokentiy.


-----Examples-----
Input
4 3

Output
java

Input
6 6

Output
python

Input
5 2

Output
phphp



-----Note-----

In the first test there is one of the appropriate new passwords — java, because its length is equal to 4 and 3 distinct lowercase letters a, j and v are used in it.

In the second test there is one of the appropriate new passwords — python, because its length is equal to 6 and it consists of 6 distinct lowercase letters.

In the third test there is one of the appropriate new passwords — phphp, because its length is equal to 5 and 2 distinct lowercase letters p and h are used in it.

Pay attention the condition that no two identical symbols are consecutive is correct for all appropriate passwords in tests.

Difficulty: EASY

Solutions:
(n, k) = list(map(int, input().split()))
letters = list(map(chr, range(97, 123)))
sol = ''.join(letters[0:k] * n)
print(sol[0:n])


(n, k) = map(int, input().split())
a = [chr(i) for i in range(ord('a'), ord('a') + k)]
a = ''.join(a)
s = a * (n // k) + a[:n % k]
print(s)


(n, k) = map(int, input().split())
last = list(map(chr, range(ord('a'), ord('a') + k)))
p = 0
for i in range(n):
	print(last[p], end='')
	p = (p + 1) % len(last)


(n, k) = map(int, input().split())
if k > 26:
	k = 26
m = ('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')
i = 0
s = ''
c = ''
while i < k:
	s += m[i]
	i += 1
i = 0
while i < n % k:
	c += m[i]
	i += 1
print(s * (n // k) + c)


(x, y) = input().split()
(x, y) = (int(x), int(y))
str1 = str()
i = 0
while len(str1) < x:
	if i >= y:
		i = 0
	str1 += chr(97 + i)
	i += 1
print(str1)


(n, k) = map(int, input().split())
a = 'abcdefghijklmnopqrstuvwxyz'
print((a[:k] * n)[:n])


import sys
length = 0
distinct = 0
letters = ['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']
for line in sys.stdin:
	line = line.split()
	length = int(line[0])
	distinct = int(line[1])
	break
new_pass = ''
letters_to_use = letters[:distinct]
idx = 0
for i in range(length):
	if idx >= len(letters_to_use):
		idx = 0
	new_pass += letters_to_use[idx]
	idx += 1
print(new_pass)


(n, m) = map(int, input().split())
print(('abcdefghijklmnopqrstuvwxyz'[:m] * n)[:n])


numbers = [int(i) for i in input().split()]
n = numbers[0]
k = numbers[1]
letters = 'abcdefghijklmnopqrstuvwxyz'
reps = n // k
remains = n % k
if n < 26:
	password = letters[0:n + 1]
	new_password = password[0:k] * reps + password[0:remains]
	print(new_password)
else:
	reps1 = n // 26
	remains1 = n % 26
	password = letters[0:26] * reps1 + letters[0:remains1]
	new_password = password[0:k] * reps + password[0:remains]
	print(new_password)


(a, b) = map(int, input().split())
for i in range(a):
	print(chr(97 + i % b), end='')


(m, n) = map(int, input().split())
a = 'abcdefghijklmnopqrstuvwxyz'
s = a[0:n] * (m // n)
s += a[0:m % n]
print(s)


(n, k) = map(lambda x: int(x), input().split(' '))
s = [chr(97 + i) for i in range(k)]
ans = []
for i in range(n):
	ans.append(s[i % len(s)])
print(str.join('', ans))


(n, k) = map(int, input().split())
ans = ''
for i in range(k):
	ans += chr(97 + i)
ans *= 100
print(ans[:n])


import sys
(a, b) = input().split()
a = int(a)
b = int(b)
s = ''
d = 'a'
if a == 1 and b == 1:
	print('a')
	sys.exit()
for x in range(b):
	s += d
	d = chr(ord(d) + 1)
ret = ''
while len(ret) < a:
	ret += s
print(ret[0:a])


import string
l = list(string.ascii_lowercase)
(n, k) = [int(x) for x in input().split()]
ans = l[:k] * (n // k)
ans += ans[:n % k]
print(''.join(ans))


(n, k) = map(int, input().split())
l = 'abcdefghijklmnopqrstuvwxyz'
a = ''
for i in range(n):
	a = a + l[i % k]
print(a)


import random
import string
import math
(n, k) = map(int, input().split())
s = string.ascii_letters
h = ''
for j in range(k):
	h = h + s[j]
m = n / k
m = math.ceil(m)
a = h * m
c = ''
for i in range(n):
	c = c + a[i]
print(c)


(n, k) = map(int, input().split())
lst = []
for i in range(n):
	lst.append(chr(ord('a') + i % k))
result_str = ''.join((i for i in lst))
print(result_str)


(n, k) = list(map(int, input().split()))
b = 'abcdefghijklmnopqrstuvwxyz'
c = b[:k]
print(c * (n // k), c[:n % k], sep='')


stri = 'abcdefghijklmnopqrstuvwxyz'
mod = 0
strj = ''
(x, y) = map(int, input().split())
for i in range(x // y):
	strj += stri[0:y]
if x % y != 0:
	mod = x % y
	strj += stri[0:mod]
print(strj)


s = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
temp = s[:k]
t = n // k
if n % k == 0:
	print(t * temp)
else:
	ans = t * temp + temp
	print(ans[:n])


(n, k) = map(int, input().split())
z = ['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']
list = []
for i in range(k):
	list.append(z[i])
for i in range(n - k):
	list.append(list[i])
for i in range(1):
	for j in range(len(list)):
		print(list[j], end='')


import string
(n, k) = map(int, input().split())
a = list(string.ascii_lowercase)
f = str()
i = 0
while len(f) != n:
	if i < k:
		f += a[i]
		i += 1
	else:
		i = 0
print(f)


import string
(n, k) = (int(x) for x in input().split())
symbols = string.ascii_lowercase[0:k]
if n > k:
	symbols *= n // k + 1
pwd = symbols[0:n]
print(pwd)


import sys
input = sys.stdin.readline
output = sys.stdout

def solve(n, k):
	new = []
	l = [chr(x) for x in range(97, 97 + k)]
	for i in range(n):
		new.append(l[i % k])
	output.write(''.join(new) + '\n')
n = list(map(int, input().split()))
solve(n[0], n[1])


(n, k) = [int(x) for x in input().split()]
kc = k
alfabeto = list('abcdefghijklmnopqrstuvwxyz')
passw = ''
i = 0
while kc > 0:
	passw += alfabeto[i]
	kc -= 1
	i += 1
i = 0
while len(passw) < n:
	passw += passw[i]
	i += 1
print(passw)


import random
num = list(map(int, input().split()))
s = ''
for i in range(0, num[0]):
	s += chr(ord('a') + i % num[1])
print(s)


(n, k) = map(int, input().split())
chars = [chr(ord('a') + i) for i in range(k)]
sub = ''.join(chars)
res = sub * (n // k) + sub[:n % k]
print(res)


(n, k) = input().split()
print(''.join([chr(97 + i % int(k)) for i in range(int(n))]))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = 1
	rr = []
	for _ in range(t):
		(n, k) = LI()
		t = string.ascii_lowercase[:k]
		r = t * (n // k) + t[:n % k]
		rr.append(r)
	return JA(rr, '\n')
print(main())


import string
letters = list(string.ascii_lowercase)
(x, k) = map(int, input().split())
password = ''
for i in range(x):
	if i + 1 <= k:
		password = password + letters[i]
	else:
		password = password + letters[i - i // k * k]
print(password)


import string
ascii_letters = string.ascii_letters
(n, k) = map(int, input().split())
ascii_letters = ascii_letters[0:k]
res = ascii_letters
if n > k:
	res = res * (n // k) + res[0:n % k]
print(res)


import string
alphabet = list(string.ascii_lowercase)
(n, k) = map(int, input().split())
for i in range(n):
	print(alphabet[i % k], end='')
print()


from string import ascii_letters
(n, k) = map(int, input().split())
l = ascii_letters
a = ''
for i in range(n):
	a = a + l[i % k]
print(a)


(n, m) = list(map(int, input().strip().split()))
l = []
for i in range(97, 97 + m):
	l.append(chr(i))
for i in range(0, n):
	print(l[i % m], end='')


string = str(input())
arr = string.split()
n = int(arr[0])
k = int(arr[1])
alpha = ['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']
arr2 = []
for i in range(k):
	arr2.append(alpha[i % 26])
a = n - k
ans = ''
for i in arr2:
	ans += i
for i in range(a):
	ans += arr2[i % k]
print(ans)


from math import floor, sqrt
from sys import stdin
for _ in range(1):
	(n, k) = map(int, input().split())
	password = ''
	j = 0
	for i in range(n):
		password = password + chr(97 + j % k)
		j += 1
	print(password)


(n, k) = map(int, input().split())
(i, j) = (0, 0)
while i < n:
	if j < k:
		print(chr(97 + j), end='')
	else:
		print('a', end='')
		j = 0
	i += 1
	j += 1


(n, k) = list(map(int, input().split()))
chars = ['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']
use_chars = chars[:k]
password = ' '
x = 0
for char_i in range(1, n + 1):
	current_char = use_chars[x]
	if password[char_i - 1] == current_char:
		current_char = use_chars[x]
	if x + 1 == k:
		x = 0
	else:
		x += 1
	password += current_char
print(password[1:])


a = list(map(int, input().split()))
n = a[0]
k = a[1]
alph = 'abcdefghijklmnopqrstuvwxyz'
hi = n // k
hg = n % k
result = hi * alph[:k] + alph[:hg]
print(result)


import sys
(n, k) = input().split()
n = int(n)
k = int(k)
s = ''
d = 'a'
if k >= 2:
	for x in range(k):
		s += d
		d = chr(ord(d) + 1)
	ret = ''
	while len(ret) < n:
		ret += s
	print(ret[0:n])


z = list(map(int, input().split()))
a = ''
c = 0
for i in range(97, 123):
	a += chr(97 + c)
	c += 1
	if c == z[1]:
		break
while len(a) != z[0]:
	a += a[:z[0] - len(a)]
print(a)


bkvs = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = (int(i) for i in input().split())
cp = n // k
ost = n % k
print(bkvs[:k] * cp + bkvs[:ost])


(n, k) = map(int, input().split())
y = ''
for i in range(n):
	y += chr(97 + i % k)
print(y)


letters = [chr(i) for i in range(97, 123)]
(n, k) = map(int, input().split())
password = ''
for i in range(n):
	cur = i % k
	password += letters[cur]
print(password)


(n, k) = map(int, input().split())
a = 'abcdefghijklmnopqrstuvwxyz'
i = 0
j = 0
s = ''
while i < n:
	s += a[j]
	i += 1
	j += 1
	if j == k:
		j = 0
print(s)


def list_from_input():
	return list(map(int, input().split()))
from string import ascii_lowercase

def main():
	(n, k) = list_from_input()
	password_range = ascii_lowercase[:k]
	password = ''
	i = 0
	while len(password) < n:
		password += password_range[i % k]
		i += 1
	print(password)
main()


x = input()
x = list(map(int, x.strip().split()))
n = x[0]
k = x[1]
count = 0
output = ''
for i in range(n):
	if count < k - 1:
		output = output + chr(ord('a') + count)
		count += 1
	else:
		output = output + chr(ord('a') + count)
		count = 0
print(str(output))


b = input().split()
s = 'abcdefghijklmnopqrstuvwxyz'
g = int(b[0])
f = int(b[1])
d = []
while len(d) < g:
	i = 0
	while i < f:
		if len(d) == g:
			break
		d.append(s[i])
		i = i + 1
print(''.join(d))


from string import ascii_lowercase as a
from itertools import cycle
(n, k) = map(int, input().split())
c = cycle(a[:k])
for i in range(n):
	print(next(c), end='')


(a, b) = [int(x) for x in input().split(' ')]
print(('abcdefghijklmnopqrstuvwxyz'[:b] * 100)[:a])


(n, k) = list(map(int, input().split()))
s = 'abcdefghijklmnopqrstuvwxyz'
res = ''
for i in range(n):
	res += s[i % k]
print(res)


n = list(map(int, input().split()))
(n, m) = (n[0], n[1])
s = 'abcdefghijklmnopqrstuvwxyz'
s2 = ''
s3 = ''
for i in range(m):
	s2 += s[i]
g = 0
for i in range(n):
	if g == m:
		g = 0
	s3 += s2[g]
	g += 1
print(s3)


(n, k) = list(map(int, input().split()))
vse_bukvi = 'abcdefghijklmnopqrstuvwxyz'
budem_usati = vse_bukvi[0:k]
next_bukva = 0
password = []
for i in range(n):
	password.append(budem_usati[next_bukva])
	if next_bukva == k - 1:
		next_bukva = 0
	else:
		next_bukva += 1
print(''.join(password))


s = 'abcdefghijklmnopqrstuvwxyz'
(a, b) = input().split()
for i in range(0, int(b)):
	print(s[i], end='')
diff = int(a) - int(b)
j = 0
for i in range(0, diff, 1):
	print(s[j], end='')
	j += 1
	if j == int(b):
		j = 0


(n, k) = [int(x) for x in input().split(' ')]
symbols = 'abcdefghijklmnopqrstuvwxyz'
newPsw = ''
q = 0
for i in range(n):
	if q == k:
		q = 0
	newPsw += symbols[q]
	q += 1
print(newPsw)


alph = 'abcdefghijklmnopqrstuvwxyz'
import sys
(n, k) = [int(i) for i in sys.stdin.readlines()[0].split()]
password = ''
alph = alph[:k]
i = 0
while len(password) < n:
	password = password + alph[i]
	i = i + 1
	if i == k:
		i = 0
print(password)


(n, k) = map(int, input().split())
latin = 'abcdefghijklmnopqrstuvwxyz'
p = ''
for i in range(n):
	p += latin[i % k]
print(p)


import sys
fin = sys.stdin
fout = sys.stdout
(n, k) = map(int, fin.readline().split())
first = ''
for i in range(k):
	first += chr(97 + i)
ans = first
for i in range(n - k):
	ans += first[i % k]
fout.write(str(ans))


alpha = 'abcdefghijklmnopqrstuvwxyz'
(n, m) = map(int, input().split())
s = ''
s += alpha[0:m]
i = 0
while len(s) < n:
	s += chr(ord('a') + i)
	i += 1
	if i == m:
		i = 0
print(s)


ls = [chr(i) for i in range(97, 123)]
(n, k) = input().strip().split(' ')
(n, k) = (int(n), int(k))
l = []
l1 = ls[0:min(k, 26)]
i = -1
while len(l) < n:
	i = (i + 1) % k
	l.append(l1[i])
print(''.join(l))


raw = list(map(int, input().split()))
n = raw[0]
k = raw[1]
string = ''
difference = n - k
for i in range(97, 97 + k):
	string += chr(i)
leng = len(string)
current = string
while difference > 0:
	string += current
	difference -= leng
while difference != 0:
	string = string[0:-1]
	difference += 1
print(string)


(n, m) = map(int, input().split())
a = ord('a')
alph = [chr(i) for i in range(a, a + 26)]
s = ''
for i in range(m):
	s = s + alph[i]
for i in range(n - m):
	s = s + s
	if len(s) > n + 2:
		break
s = s[0:n]
print(s)


def main():
	(n, k) = map(int, input().split())
	chars = 'abcdefghijklmnopqrstuvwxyz'
	chars = chars[:k]
	password = ''
	for i in range(n):
		pos = i % k
		password += chars[pos]
	print(password)
main()


(n, k) = map(int, input().split())
A = [0] * n
m = 97
for i in range(k):
	A[i] = chr(m)
	m += 1
j = k
while j < n:
	A[j] = A[j - k]
	j += 1
print(''.join(A))


def generateK(k):
	ascii_letters = []
	range_lower_case = list(range(97, 123))
	for i in range(k):
		if range_lower_case[i] not in ascii_letters:
			ascii_letters.append(chr(range_lower_case[i]))
	return ascii_letters

def generateN(n, ascii):
	n_password = ''
	for i in range(n):
		k = i % len(ascii)
		n_password += ascii[k]
	return n_password

def generate_new_password():
	(n, k) = [int(x) for x in input().split()]
	if n >= k:
		ascii_letters = generateK(k)
		password = generateN(n, ascii_letters)
		print(password)
generate_new_password()


import sys
(n, k) = input().split()
n = int(n)
k = int(k)
s = ''
x = k
for i in range(n):
	if k > 0:
		s = s + chr(97 + i)
		k -= 1
	else:
		for j in range(x):
			s = s + chr(97 + j)
			j += 1
			if len(s) == n:
				print(s)
				sys.exit()
print(s)


(n, k) = map(int, input().split())
ptr = 97
check = 0
ans = ''
for _ in range(n):
	ans += chr(ptr)
	check += 1
	if check >= k:
		check = 0
		ptr = 97
	else:
		ptr += 1
print(ans)


(n, k) = map(int, input().split())
l = []
z = ''
if n == k:
	for i in range(n):
		l.append(chr(97 + i))
else:
	while n - len(l) > k:
		for i in range(k):
			l.append(chr(97 + i))
	for i in range(0, n - len(l)):
		l.append(chr(97 + i))
z = ''.join(map(str, l))
print(z)


alph = list('abcdefghijklmnopqrstuvwxyz')
(ln, sy) = map(int, input().split())
chars = alph[:sy]
pw = ''
for i in range(ln):
	pw += chars[i % len(chars)]
print(pw)


(n, k) = map(int, input().split())
pwd = ''
for x in range(97, 97 + k):
	pwd += chr(x)
for y in range(n - k):
	pwd += pwd[y]
print(pwd)


inps = input().split()
n = int(inps[0])
k = int(inps[1])
password = ''
for i in range(k):
	password += chr(97 + i)
for i in range(n - k):
	password += password[i]
print(password)


(n, k) = [int(i) for i in input().split()]
l = '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'
l = [i for i in l.split(' ')]
temp = []
f = ''
if k >= n:
	i = 0
	while n != 0:
		f += l[i]
		n -= 1
		i += 1
	print(f)
else:
	i = 0
	letters_left = n - k
	while k != 0:
		f += l[i]
		k -= 1
		temp.append(l[i])
		i += 1
	temp = ''.join(temp)
	temp *= letters_left
	i = 0
	while letters_left != 0:
		f += temp[i]
		letters_left -= 1
		i += 1
	print(f)


import sys
import math
input = sys.stdin.readline
(n, m) = map(int, input().split())
ans = ''
for i in range(min(n, m)):
	ans += chr(ord('a') + i)
for i in range(max(0, n - m)):
	ans += chr(ord('a') + i % m)
print(ans)


(n, k) = [int(x) for x in input().split()]
word = 'abcdefghijklmnopqrstuvwxyz'
password = ''
for i in range(n):
	password = password + word[i % k]
print(password)


(q, w) = [int(x) for x in input().split()]
e = ''
i = 0
pis = 0
while pis < q:
	e += chr(ord('a') + i)
	i = i + 1
	pis = pis + 1
	if i >= w:
		i = 0
print(e)


import operator as op
import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from functools import reduce
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

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

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def def_value():
	return []
(n, k) = invr()
temp = ''
for i in range(k):
	temp += chr(i + ord('a'))
mul = n // k + 1
res = temp * mul
print(res[:n])


(n, k) = map(int, input().split())
ch = []
for i in range(1, k + 1):
	ch.append(chr(i + 96))
if n <= k:
	print(''.join(ch))
else:
	res = ch
	br = 0
	while True:
		for i in range(n):
			res.append(ch[i])
			k += 1
			if k == n:
				br = 1
				break
		if br == 1:
			break
	print(''.join(res))


import sys
(a, b) = input().split()
m = int(a)
n = int(b)
d = ''
k = 'abcdefghijklmnopqrstuvwxyz'
j = m // n
g = m % n
if m > n and g != 0:
	b = k[0:n]
	for i in range(0, j):
		d = d + b
	d = d + b[0:g]
	print(d)
elif m > n and g == 0:
	b = k[0:n]
	for i in range(0, j):
		d = d + b
	print(d)
else:
	print(k[0:m])


(n, k) = input().split()
j = 0
res = ''
for i in range(int(n)):
	res += chr(97 + j)
	j = (j + 1) % int(k)
print(res)


(n, k) = map(int, input().split())
o = 0
for i in range(n):
	print(chr(o + 97), end='')
	o += 1
	if o == k:
		o = 0


(n, k) = map(int, input().split())
pas = ''
arr = ['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']
for i in range(0, n):
	pas += arr[i % k]
print(pas)


(x, y) = map(int, input().split())
password = []
s = ['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']
j = 0
if x % y == 0:
	z = int(x / y)
	for i in range(z):
		j = 0
		for k in range(y):
			password.append(s[j])
			j += 1
if x % y != 0:
	z = int(x / y)
	l = x - y * z
	for i in range(z):
		j = 0
		for k in range(y):
			password.append(s[j])
			j += 1
	j = 0
	for k in range(l):
		password.append(s[j])
		j += 1
res = ''
for i in password:
	res += i
print(res)


(n, k) = map(int, input().split())
a = 'abcdefghijklmnopqrstuvwxyz'
s1 = a[:k]
i = 0
for i in range(n - k):
	s1 += s1[i]
	i += 1
	if i == k:
		i = 0
print(s1)


from random import randint

def createPassword(n, k):
	password = []
	start = 97
	end = start + k
	symbols = [chr(i) for i in range(start, end)]
	for _ in range(int(n / k)):
		password.append(''.join(symbols))
	password.append(''.join(symbols[:n % k]))
	return ''.join(password)
(n, k) = map(int, input().split())
print(createPassword(n, k))


x = input().split(' ')
n = int(x[0])
k = int(x[1])
chars = 'abcdefghijklmnopqrstuvwxyz'
password = ''
counter = 0
for i in range(n):
	password += chars[counter]
	counter += 1
	if counter >= k:
		counter = 0
print(password)


(n, m) = map(int, input().split(' '))
s = ''
k = 0
h = n - m
for i in range(m):
	c = chr(ord('a') + k)
	s += c
	k += 1
for i in range(h):
	s += s[i]
print(s)


n = input().split()
m = int(n[1])
n = int(n[0])
sym = ['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']
tmp = []
pas = ''
k = 0
for i in range(0, m):
	tmp.append(sym[i])
for i in range(n):
	pas += tmp[k]
	if k != len(tmp) - 1:
		k += 1
	else:
		k = 0
print(pas)


alp = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
psw = ''
tmp = 0
for i in range(n):
	psw += alp[tmp]
	tmp += 1
	if tmp == k:
		tmp = 0
print(psw)


(n, k) = list(map(int, input().split()))
arr = []
for i in range(k):
	arr.append(chr(97 + i))
for j in range(n - k):
	arr.append(arr[j])
print(''.join(arr))


(n, k) = map(int, input().split())
s = ''
a = 'abcdefghijklmnopqrstuvwxyz'
for i in range(n // k):
	s = s + a[0:k]
n = n % k
s = s + a[0:n]
print(s)


(n, k) = map(int, input().split())
print(''.join(('abcdefghijklmnopqrstuvwxyz'[i % k] for i in range(n))))


(n, k) = [int(x) for x in input('').split()]
str = ''
pos = 0
while len(str) < n:
	if pos == k:
		pos = 0
	str += chr(97 + pos)
	pos += 1
print(str)


let = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
s = ''
dis = []
for i in range(k):
	dis.append(let[i])
for i in range(n):
	for j in range(k):
		if len(s) == n:
			break
		s += dis[j]
print(s)


import string
res = string.ascii_lowercase[:26]
(n, r) = map(int, input().split())
s = res[:r]
for i in range(n - r):
	if len(s) != n:
		for j in range(1):
			s += s[j + i]
			break
	else:
		break
print(s)


(n, k) = map(int, input().split())
array = range(97, 97 + k)
_str = ''
for i in range(n):
	_str += chr(array[i % k])
print(_str)


(n, k) = list(map(int, input().split()))
s = 'abcdefghijklmnopqrstuvwxyz'
m = min(k, 26)
z = n // m
ans = ''
for i in range(z):
	ans += s[:k]
ans += s[:n % m]
print(ans)


import string
(n, k) = map(int, input().split(' '))
ans = ''
for i in range(n):
	ans += string.ascii_lowercase[i % k]
print(ans)


from math import *
(n, k) = map(int, input().split())
check = []
for i in range(26):
	check.append(chr(i + 97))
ans = ''
count = 0
for i in range(n // k):
	for j in range(k):
		ans += check[j]
		print(check[j], end='')
		count += 1
for i in range(n % k):
	if ans[-1] != 'a':
		print(check[i], end='')
	else:
		print(check[i + 1], end='')


(n, k) = map(int, input().split())
ans = ''
for i in range(n):
	ans += chr(ord('a') + i % k)
print(ans)


inpt = input().split()
n = int(inpt[0])
k = int(inpt[1])
charset = 'abcdefghijklmnopqrstuvwxyz'
password = ''
index = 0
while len(password) != n:
	password += charset[index]
	index = (index + 1) % k
print(password)


(length, different) = map(int, input().split(' '))
import string
result = string.ascii_lowercase[:different]
left = length - different
from_string = result
current = 0
while left > 0:
	result += from_string[current]
	left -= 1
	if current == len(from_string) - 1:
		current = 0
	else:
		current += 1
print(result)


Alpha = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
N = n // k
R = n % k
Ans = ''
for i in range(N):
	Ans += Alpha[:k]
Ans += Alpha[:R]
print(Ans)


from string import ascii_lowercase
(n, k) = map(int, input().split())
answer = ''
for i in range(n):
	answer += ascii_lowercase[i % k]
print(answer)


al = 'abcdefghijklmnopqrstuvwxyz'
(size, distinct) = map(int, input().split())
ans = ''
i = 0
while size > 0:
	ans += al[i]
	i += 1
	if i == distinct:
		i = 0
	size -= 1
print(ans)


ls = list(map(int, input().split()))
n = ls[0]
k = ls[1]
a = ''
for c in range(97, 97 + k):
	a = a + chr(c)
for i in range(n - k):
	a = a + a[i]
print(a)


from string import ascii_lowercase
(n, k) = map(int, input().split())
print(ascii_lowercase[:k] * (n // k) + ascii_lowercase[:n % k])


(n, k) = map(int, input().split())
t = [chr(ord('a') + x) for x in range(k)]
res = ''
(f, p) = (0, 0)
for i in range(n):
	res += t[f]
	f = (f + 1) % k
print(res)


x = list(map(int, input().split()))
dist_lett = []
for i in range(x[1]):
	dist_lett.append(chr(97 + i))
for j in range(x[0] - x[1]):
	dist_lett.append(dist_lett[j])
print(''.join(map(str, dist_lett)))


(n, k) = map(int, input().split())
alphabet = list(map(chr, range(97, 123)))
ans = ''
i = 0
while len(ans) < n:
	ans += alphabet[i]
	if i + 1 == k or i == 26:
		i = 0
	else:
		i += 1
print(ans)


(n, k) = map(int, input().split())
a = []
b = 'a'
for i in range(k):
	a.append(chr(ord(b) + i))
j = 0
for i in range(n):
	print(a[j], end='')
	j = j + 1
	if j == len(a):
		j = 0


l = input().split()
n = int(l[0])
k = int(l[1])
letters = 'abcdefghijklmnopqrstuvwxyz'
password = ''
for i in range(n):
	password += letters[i % k]
print(password)


def main():
	(n, k) = map(int, input().split())
	symbols = ''.join((chr(x) for x in range(ord('a'), ord('a') + k)))
	full = n // k
	left = n - full * k
	print(symbols * full + symbols[:left])
main()


(passwordLength, distinctSymbols) = map(int, input().split())
alphabets = 'abcdefghijklmnopqrstuvwxyz'
characters = alphabets[:distinctSymbols]
password = ''
i = 0
for i in range(passwordLength):
	password += characters[i % distinctSymbols]
print(password)


from string import ascii_lowercase
(n, k) = map(int, input().split())
sym = []
for i in ascii_lowercase:
	sym.append(i)
ans = []
for i in range(k):
	ans.append(sym[i])
z = 0
for i in range(k, n):
	ans.append(ans[z])
	z += 1
	if z == k:
		z = 0
print(''.join(ans))


(n, k) = map(int, input().split())
letters = 'abcdefghijklmnopqrstuvwxyz'
password = ''
i = 0
while n > 0:
	password += letters[i]
	i += 1
	n -= 1
	if i == k:
		i = 0
print(password)


(n, k) = map(int, input().split())
s = ''
for i in range(k):
	s += chr(97 + i)
while len(s) < n:
	s += s
print(s[0:n])


(n, k) = map(int, input().split())
m = min(n, k)
s = ''
for i in range(m):
	s += chr(97 + i)
s += s * ((n - k) // k)
s += s[:n % k]
print(s)


import math
import os
import random
import re
from sys import stdin, stdout
from collections import Counter
from itertools import permutations

def si():
	return str(stdin.readline())

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())

def debug(x):
	return stdout.write(str(x))
(m, n) = mi()
for i in range(m):
	print(chr(97 + i % n), end='')


import string
inp = list(map(int, input().rstrip().split()))
s = string.ascii_lowercase
l = inp[0]
d = inp[1]
new_p = ''
avail = s[:d]
f = 1
while f:
	if len(new_p) < l:
		new_p += avail
	else:
		new_p = new_p[:l]
		f = 0
print(new_p)


from collections import Counter, defaultdict, deque
alph = 'abcdefghijklmnopqrstuvwxyz'
import math
import sys
input = sys.stdin.readline
(n, k) = [int(x) for x in input().split()]
s = alph[:k] * 100
print(s[:n])


(n, k) = [int(x) for x in input().split()]
kc = k
alphabet = 'abcdefghijklmnopqrstuvwxyz'
alphabet = list(alphabet)
password = ''
i = 0
while kc > 0:
	password += alphabet[i]
	kc -= 1
	i += 1
i = 0
while len(password) < n:
	if i == k:
		i = 0
	password += password[i]
	i += 1
print(password)


def password():
	inp = list(map(int, input().strip().split()))
	s = ''
	for i in range(inp[0]):
		s += chr(ord('a') + i % inp[1])
	return s
print(password())


def create_new_password(n, k):
	password = ''
	for i in range(k):
		password += chr(ord('a') + i)
	for i in range(n - k):
		password += password[i]
	return password
str_inp = input().split()
n = int(str_inp[0])
k = int(str_inp[1])
print(create_new_password(n, k))


def main():
	(n, k) = (int(inp) for inp in input().split())
	ascii_start_lowercase = 97
	password = ''.join([chr(97 + i % k) for i in range(n)])
	print(password)
	return password
main()


import string
(n, k) = map(int, input().split(' '))
var = string.ascii_lowercase[:k]
var *= n // k
x = n % k
var += var[:x]
print(var)


import string
(n, k) = (int(i) for i in input().split())
str = string.ascii_lowercase[:k]
ans = str * (n // k) + str[:n % k]
print(ans)


import sys
from statistics import mean
input = sys.stdin.readline

def inp():
	return int(input())

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

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

def invr():
	return map(int, input().split())
(n, k) = invr()
res = ''
for j in range(97, 97 + k):
	res = res + chr(j)
if n >= k:
	x = int(n / k)
	y = int(n % k)
	for i in range(x):
		print(res, end='')
	li = list(res)
	for i in range(0, y):
		print(''.join(res[i]), end='')
else:
	li = list(res)
	for i in range(0, n):
		print(''.join(res[i]), end='')


(n, k) = input().split()
n = int(n)
k = int(k)
begin = ord('a')
s = ''
for i in range(n):
	s += chr(i % k + begin)
print(s)


(n, k) = list(map(int, input().split()))
s = 'abcdefghijklmnopqrstuvwxyz'
line = s[:k] * 50
print(line[:n])


import string
(n, k) = map(int, input().split())
alpha = list(string.ascii_lowercase)[0:k]
s = ''
cur_alpha = 0
for i in range(n):
	s += alpha[cur_alpha]
	cur_alpha = (cur_alpha + 1) % k
print(s)


import string
(a, b) = input().strip().split(' ')
(a, b) = [int(a), int(b)]
s = ''
q = 0
for j in range(a):
	if q == b:
		q = 0
	s = s + string.ascii_lowercase[q]
	q = q + 1
print(s)


m = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
z = m[:k]
z = z * (n // k)
print(z + z[:n - len(z)])


import string
letters = string.ascii_lowercase
(n, k) = list(map(int, input().split(' ')))
for i in range(n):
	coordinate = i % k
	print(letters[coordinate], end='')
print()


(pass_len, unique_chars) = [int(i) for i in input().split()]
alpha_set = []
start = 'a'
for i in range(unique_chars):
	if i == 0:
		alpha_set.append(start)
	else:
		start = chr(ord(start) + 1)
		alpha_set.append(start)
curr_pos = 0
pass_output = ''
for i in range(pass_len):
	pass_output += alpha_set[i % unique_chars]
print(pass_output)


def main():
	(n, k) = map(int, input().split())
	base = [chr(i) for i in range(97, 123)]
	a = ''
	for i in range(n):
		for j in range(k):
			a += base[j]
			if len(a) == n:
				return a
print(main())


(n, k) = map(int, input().split())
s = 'abcdefghijklmnopqrstuvwxyz'
while n != 0:
	if n >= k:
		print(s[:k], end='')
		n -= k
	else:
		print(s[:n], end='')
		n = 0


import string
(n, k) = [int(s) for s in input().split(' ')]
x = (string.ascii_lowercase[:k] * (n // k + 1))[:n]
print(x)


(n, k) = [int(x) for x in input().split()]
arr = 'abcdefghijklmnopqrstuvwxyz'
password = ''
if n == k:
	password = arr[0:k]
	print(password)
elif n % k == 0:
	for i in range(n // k):
		password = password + arr[0:k]
	print(password)
else:
	for i in range(n // k):
		password = password + arr[0:k]
	print(password + arr[0:n % k])


ans = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
ans = ans[:k]
ans = ans * (n // k)
rem = n % k
ans += ans[0:rem]
print(ans)


(n, k) = list(map(int, input().split(' ')))
alpha = 'abcdefghijklmnopqrstuvwxyz'
bucket = alpha[:k]
res = ''
while n - len(bucket) > 0:
	res += bucket
	n -= len(bucket)
res += bucket[:n]
print(res)


(n, k) = map(int, input().split())
s = 'abcdefghijklmnopqrstuvwxyz'
an = ''
i = 0
while len(an) < n:
	an += s[i % k]
	i += 1
print(an)


import string
alphabet = list(string.ascii_lowercase)
(n, k) = input().split()
n = int(n)
k = int(k)
possible_syms = alphabet[0:k]
final = ''
if n >= k:
	tmp_s = ''.join(possible_syms)
	final += tmp_s
	n -= k
while n >= k:
	final += tmp_s
	n -= k
possible_syms_last = possible_syms[0:n]
tmp_s = ''.join(possible_syms_last)
final += tmp_s
print(final)


(n, k) = list(map(int, input().split()))
s = ''
for i in range(k):
	s += chr(ord('a') + i)
m = n // k
res = s * m
res += s[:n % k]
print(res)


(n, k) = map(int, input().split())
s = ''
i = 0
while i < n:
	for j in range(97, 97 + k):
		if i >= n:
			break
		s += chr(j)
		i += 1
print(s)


(n, k) = map(int, input().split())
s = 'abcdefghijklmnopqrstuvwxyz'[:k]
print(s * (n // k) + s[:n % k])


(n, k) = [int(x) for x in input().split(sep=' ')]
a_z = 'abcdefghijklmnopqrstuvwxyz'
passwd = ''
for i in range(0, n):
	passwd = passwd + a_z[i % k]
print(passwd)


(n, k) = map(int, input().split(' '))
st = ''
for i in range(97, 97 + k):
	st += chr(i)
x = 0
x = n - k
if x == 0:
	print(st)
if x > 0:
	for i in range(0, x):
		st += st[i]
	print(st)


import string
input_params = input().split(' ')
pass_length = int(input_params[0])
unique_symbols = int(input_params[1])
alphabet = string.ascii_lowercase
sub_str = alphabet[:unique_symbols]
division = divmod(pass_length, unique_symbols)
div = division[0]
mod = division[1]
result = ''
if div > 0:
	for i in range(div):
		result += sub_str
result += sub_str[:mod]
print(result)


from string import ascii_lowercase as alpha

def solve(n, k):
	dst_char = alpha[:k]
	str = ''
	l = 0
	while len(str) != n:
		str += dst_char[l]
		l += 1
		if l == k:
			l = 0
	return str
(n, k) = list(map(int, input().split()))
print(solve(n, k))


(n, k) = map(int, input().split())
s = ''
w = ''
q = 0
for i in range(97, 97 + k):
	s += chr(i)
for i in range(n):
	w += s[q]
	q += 1
	if q == k:
		q = 0
print(w)


import string
(n, k) = map(int, input().split())
letters = string.ascii_lowercase
password = ''
for i in range(k):
	password += letters[i]
i = 0
while len(password) < n:
	password += password[i]
	i += 1
print(password)


from string import ascii_lowercase
(n, k) = str(input()).split()
n = int(n)
k = int(k)
c = 0
if n < k:
	print(ascii_lowercase[0:n])
r = n % k
rep = n // k
s = ascii_lowercase[0:k]
us = rep * s
mus = us + ascii_lowercase[0:r]
print(mus)


(n, k) = input().split()
n = int(n)
k = int(k)
s = 'abcdefghijklmnopqrstuvwxyz'
substr = s[:k] * (n // k + 1)
print(substr[:n])


print((lambda n, k: ('abcdefghijklmnopqrstuvwxyz'[:k] * ((n + k - 1) // k))[:n])(*list(map(int, input().split()))))


(n, k) = map(int, input().split())
str = ''
c = 0
for i in range(n):
	str = str + chr(c + 97)
	c += 1
	if c == k:
		c = 0
print(str)


import sys
from math import ceil, log, gcd
RI = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('Yes')

def NO():
	print('No')
INF = 10 ** 18
MOD = 10 ** 9 + 7
(n, k) = RI()
ans = []
ite = 0
for i in range(n):
	ans.append(chr(ord('a') + ite))
	ite = (ite + 1) % k
print(''.join(ans))


(n, k) = map(int, input().split())
l = []
z = 0
for i in range(k):
	l.append(chr(i + 97))
for i in range(n):
	z = i // k
	print(l[i - z * k], end='')


(n, k) = map(int, input().split())
a = ''
count = 0
for i in range(n):
	a += chr(97 + count)
	count += 1
	if count == k:
		count = 0
print(a)


__author__ = 'Ryabchun Vladimir'
(n, k) = map(int, input().split())
answer = ''
last = 96
used = []
while len(answer) != n:
	if last >= 96 + k:
		last = 97
	else:
		last += 1
	answer += chr(last)
print(answer)


(n, k) = [int(x) for x in input().split()]
s = 'abcdefghijklmnopqrstuvwxyz'
q_s = ''
r_s = ''
for i in range(0, k):
	q_s += s[i]
rem = n - n // k * k
for i in range(rem):
	r_s += s[i]
print(q_s * (n // k) + r_s)


from string import ascii_lowercase
(n, k) = map(int, input().split())
index = 0
for i in range(n):
	if index >= k:
		index = 0
	print(ascii_lowercase[index], end='')
	index += 1


(n, k) = map(int, input().split())
l = []
p = [i for i in l]
for i in range(1, k + 1):
	l.append(chr(i + 96))
while len(p) < n:
	for j in l:
		p.append(j)
p = ''.join(p)
print(p[0:n])


(n, k) = map(int, input().split())
charecters = []
for i in range(k):
	a = chr(ord('a') + i)
	charecters.append(a)
n = n - k
i = 0
j = 0
s = ''
while i < n:
	s += charecters[j % k]
	j += 1
	i += 1
ans = ''
for i in charecters:
	ans += i
print(ans + s)


n = list(map(int, input().split()))
s = ''
z = 'abcdefghijklmnopqrstuvwxyz'
for i in range(n[1]):
	s += z[i]
if len(s) != n[0]:
	w = n[0] - len(s)
	for i in range(w):
		s += s[i]
print(s)


nk = input().split()
n = int(nk[0])
k = int(nk[1])
password = ''
i = 0
j = 0
for i in range(n):
	if j < k:
		password = password + chr(97 + j)
		j += 1
	else:
		j = 0
		password = password + chr(97 + j)
		j += 1
print(password)


lat = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
sd = lat[:k]
st = sd * (n // k + 1)
st = st[:-(len(st) - n)]
print(st)


(n, k) = [int(c) for c in input().split(' ')]
aCode = ord('a')
(passwordd, er) = ('', '')
for i in range(0, k):
	er += chr(aCode + i)
count = n // k
rest = n % k
passwordd = er * count
if rest > 0:
	passwordd += er[:rest]
print(passwordd)


[n, k] = [int(x) for x in input().split()]
s = ''
for i in range(n):
	s += chr(i % k + 97)
print(s)


(n, k) = map(int, input().split())
abc = 'abcdefghijklmnopqrstuvwxyz'
for i in range(n):
	print(abc[i % k], end='')
print()


(n, k) = map(int, input().split())
a = []
for i in range(k):
	x = ord('a')
	a.append(chr(x + i))
if n > k:
	i = 0
	while len(a) < n:
		a.append(a[i])
		i += 1
		if i == len(a):
			i = 0
print(*a, sep='')


import string
a = string.ascii_lowercase
s = input().split(' ')
n = int(s[0])
k = int(s[1])
ans = ''
for i in range(n):
	ans += a[i % k]
print(ans)


(a, b) = list(map(int, input().split()))
s = 'abcdefghijklmnopqrstuvwxyz'
line = s[:b] * 50
print(line[:a])


def password(n, k):
	s = ''
	for i in range(n):
		s += chr(97 + i % k)
	return s
(N, K) = [int(j) for j in input().split()]
print(password(N, K))


(n, k) = map(int, input().split())
chars_dis = (n // k + 1) * [chr(i + 97) for i in range(k)]
print(''.join(chars_dis[:n]))


nk = input().strip().split(' ')
n = int(nk[0])
k = int(nk[1])
seed = ord('a')
vocab = ''.join([chr(i) for i in range(seed, seed + k)])
if n <= k:
	print(vocab[:n])
else:
	password = ''
	for i in range(n // k + 1):
		password += vocab
	print(password[:n])


get = lambda : list(map(int, input().split()))
(n, k) = get()
ans = []
l = ''.join((chr(97 + i) for i in range(k)))
print(l * (n // k) + l[:n % k])


inp = input().split()
n = int(inp[0])
k = int(inp[1])
ans = ''
loopStr = ''
word = 97
for i in range(k):
	loopStr += chr(word)
	word += 1
for i in range(n):
	ans += loopStr
	if len(ans) > n:
		break
print(ans[0:n])


(n, k) = map(int, input().split(' '))
symbols = 'abcdefghijklmnopqrstuvwxyz'
newPsw = ''
q = 0
fx = lambda q: q + 1
for i in range(n):
	newPsw += symbols[q]
	q = 0 if q == k - 1 else fx(q)
print(newPsw)


(n, k) = map(int, input().split())
al = 'abcdefghijklmnopqrstuvwxyz'
s = ''
for j in range(k):
	s += al[j]
d = n - k
if d != 0:
	while d:
		for j in range(k):
			d = d - 1
			s += al[j]
			if d == 0:
				break
print(s)


(n, k) = map(int, input().split())
s = ''
for i in range(k):
	s += chr(97 + i)
x = n % k
ss = ''
if x == 0:
	x = 1
else:
	for i in range(x):
		ss += chr(97 + i)
y = n // k
print(s * y + ss)


(n, k) = [int(x) for x in input().split()]
i = 0
string = ''
for o in range(n):
	string = string + chr(ord('a') + i)
	i = i + 1
	if i == k:
		i = 0
print(string)


alpha = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = list(map(int, input().split()))
used_lit = alpha[:k]
password = used_lit * (n // k + 1)
print(password[:n])


(n, k) = map(int, input().split(' '))
d = list(map(chr, range(ord('a'), ord('z') + 1)))
pw = str()
for i in range(k):
	pw += d[i]
if k != n:
	for i in range(n):
		pw += pw[i % k]
print(pw[0:n])


(n, k) = map(int, input().split())
chars = []
j = 97
for i in range(k):
	chars.append(chr(j))
	j += 1
pwd = ''
for i in range(n):
	pwd += chars[i % k]
print(pwd)


(n, k) = [int(x) for x in input().split()]
ch = 97
pw = ''
for i in range(0, k):
	pw += chr(ch)
	ch += 1
print(n // k * pw + pw[:n % k])


(n, k) = map(int, input().split())
s = 'abcdefghijklmnopqrstuvwxyz'
p = s[0:k]
print(p * (n // k) + s[0:n % k])


(x, y) = list(map(int, input().split()))
a = ''
for i in range(y):
	a = a + chr(ord('a') + i)
while len(a) < x:
	a = a + a
print(a[:x])


import string
(n, k) = map(int, input().split())
password = string.ascii_lowercase[:k] * (n // k) + string.ascii_lowercase[:n % k]
print(password)


(n, k) = map(int, input().split())
s = ''
i = 0
while len(s) != n:
	s += chr(97 + i)
	i += 1
	if i == k:
		i = 0
print(s)


(l, d) = map(int, input().split())
res = ''
cnt = 1
while len(res) < l:
	res += chr(96 + cnt)
	if cnt == d:
		cnt = 1
	else:
		cnt += 1
print(res)


from sys import stdin
import string

def solution():
	(n, k) = [int(x) for x in stdin.readline().strip().split()]
	alpha = string.ascii_lowercase
	i = 0
	res = ''
	for j in range(0, n):
		res += alpha[i]
		i = (i + 1) % k
	return res
print(solution())


(n, k) = map(int, input().split())
a = []
for i in range(k):
	a.append(chr(97 + i))
res = ''
b = n // k
res += b * ''.join(a)
c = n % k
res += ''.join(a[0:c])
print(res)


(n, k) = map(int, input().split())
alphabets = 'abcdefghijklmnopqrstuvwxyz'
print(alphabets[:k] * (n // k) + alphabets[:n % k])


(password_len, no_of_distinct_char) = map(int, input().split())
alpha = 'abcdefghijklmnopqrstuvwxyz'
distinct = alpha[:no_of_distinct_char]
remaining = password_len % no_of_distinct_char
repeat = password_len // no_of_distinct_char
print(distinct * repeat + distinct[:remaining])


(n, k) = list(map(int, input().split()))
s = []
l = ''
for i in range(k):
	s.append(chr(97 + i))
for i in range(len(s)):
	l += s[i]
for i in range(n // k):
	print(l, end='')
for i in range(n % k):
	print(s[i], end='')


def solution(n, k):
	lowercase = [chr(97 + i) for i in range(26)]
	password = []
	for i in range(n):
		password.append(lowercase[i % k])
	return ''.join(password)
(n, k) = map(int, input().split())
print(solution(n, k))


(n, k) = map(int, input().split())
print(('abcdefghijklmnopqrstuvwxyz'[0:k] * 1000)[0:n])


(n, k) = map(int, input().split())
alpha = 'abcdefghijklmnopqrstuvwxyz'
pas = ''
i = 0
while len(pas) != k:
	pas = pas + alpha[i]
	i += 1
upper_bound = i
i = 0
while len(pas) != n:
	if i != upper_bound:
		pas = pas + alpha[i]
		i += 1
	else:
		i = 0
		pas = pas + alpha[i]
		i += 1
print(pas)


alphabet = [x for x in 'abcdefghijklmnopqrstuvwxyz']
(N, K) = [int(x) for x in input().split()]
newpass = ''
for i in range(N // K):
	newpass += ''.join(alphabet[:K])
if len(newpass) < N:
	newpass += ''.join(alphabet[:N - len(newpass)])
print(newpass)


(n, k) = map(int, input().split())
ALL = 'abcdefghijklmnopqrstuvwxyz'
if k == 26:
	ll = ALL[:]
else:
	ll = ALL[0:k]
po = ''
while n > 0:
	for i in ll:
		if n == 0:
			break
		else:
			po = po + i
			n -= 1
print(po)


from string import ascii_lowercase
x = ascii_lowercase
(n, a) = map(int, input().split())
x = x[:a]
ans = []
counter = 0
while n != 0:
	if counter == a - 1:
		ans.append(x[counter])
		counter = 0
		n -= 1
	else:
		ans.append(x[counter])
		counter += 1
		n -= 1
print(''.join(ans))


(n, k) = (int(x) for x in input().split(' '))
password = []
characters = [chr(x) for x in range(97, 97 + k)]
j = 0
for i in range(0, n):
	if j >= k:
		j = 0
	password.append(characters[j])
	j += 1
print(''.join(password))


(n, k) = map(int, input().split())
c = [chr(x) for x in range(ord('a'), ord('a') + k)]
s = ''
for i in range(n):
	s += c[i % k]
print(s)


(n, k) = map(int, input().split())
s = 'abcdefghijklmnopqrstuvwxyz'
x = n // k
y = n % k
r = s[:k] * x
r = r + s[:y]
print(r)


(n, k) = map(int, input().split())
a = 'abcdefghijklmnopqrstuvwxyz'
s = ''
c = 0
s += a[0:k] * (n // k)
s += a[0:n % k]
print(s)


(n, k) = map(int, input().split())
letters = [chr(x) for x in range(ord('a'), ord('a') + n)]
ans = []
for i in range(n):
	ans.append(letters[i % k])
print(''.join(ans))


from string import ascii_lowercase
(n, k) = map(int, input().split())
letters = list(ascii_lowercase)
pas = []
for i in range(n):
	pas.append(letters[i % k])
print(''.join(pas))


(n, k) = map(int, input().split(' '))
a = [chr(x) for x in range(ord('a'), ord('z') + 1)]
print(*a[:k] * (n // k) + a[:n % k], sep='')


letters = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = list(map(int, input().split()))
output = ''
current = 0
for i in range(n):
	if current == k:
		current = 0
	output += letters[current]
	current += 1
print(output)


import sys
(n, k) = map(int, sys.stdin.readline().split())
s = 'abcdefghijklmnopqrstuvwxyz'
res = [s[i % k] for i in range(n)]
print(''.join(res))


st = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
st = st[:k]
if n <= k:
	print(st[:n])
elif n % k == 0:
	print(st * (n // k))
else:
	print(st * (n // k) + st[:n % k])


(n, k) = map(int, input().split())
s = 'abcdefghijklmnopqrstuvwxyz'
times = int(n / k)
print(s[:k] * times, s[:n % k], sep='')


nk = input().split()
n = int(nk[0])
k = int(nk[1])
L = [chr(97 + i) for i in range(26)]
t = ''
for i in range(0, k):
	t += L[i]
m = n // k
r = n % k
s = t * m + t[0:r]
print(s)


from itertools import cycle
import string

def Anton(ls):
	(n, k) = ls
	name = string.ascii_lowercase[:k]
	gen = cycle(name)
	res = [next(gen) for _ in range(n)]
	return ''.join(res)
print(Anton(list(map(int, input().split()))))


import math
import sys

def ri():
	return input()

def ii():
	return int(input())

def li():
	return input().split()

def mi():
	return list(map(int, input().split()))
(n, k) = mi()
r = n - k
ans = ''
a = 'abcdefghijklmnopqrstuvwxyz'
for i in range(k):
	ans += a[i % 26]
for i in range(r):
	ans += a[i % k]
print(ans)


(n, k) = map(int, input().split())
a = 0
for _ in range(n):
	print(chr(a + 97), end='')
	a += 1
	if a == k:
		a = 0


(n, k) = map(int, input().split())
a = 'abcdefghijklmnopqrstuvwxyz'
password = ''
for i in range(k):
	password = password + a[i]
b = n - len(password)
c = ''
c = c + password * b
for i in range(b):
	password = password + c[i]
print(password)


import string
from math import ceil
(n, k) = list(map(int, input().split(' ')))
letters = list(string.ascii_lowercase)
arr = letters[:k] * ceil(n / k)
password = [0] * n
for i in range(n):
	password[i] = arr[i]
print(''.join(password))


store = ''
j = 0
(n, k) = map(int, input().split())
for i in range(97, 97 + n):
	if len(store) < k:
		store += chr(i)
	else:
		store += store[j]
		j += 1
print(store)


result = ''
alph = [alph for alph in 'abcdefghijklmnopqrstuvwxyz']
s = input()
inp = s.split(' ')
nk = [int(i) for i in inp]
for i in range(0, nk[1]):
	result = result + alph[i]
i = 0
while len(result) != nk[0]:
	if i <= nk[1] - 1:
		result = result + alph[i]
		i = i + 1
	else:
		i = 0
print(result)


(n, k) = map(int, input().split())
a = list(map(chr, range(97, 97 + k)))
i = 0
j = 0
b = []
while i < n:
	b.append(a[j])
	if j == len(a) - 1:
		j = 0
	else:
		j += 1
	i += 1
for i in b:
	print(i, end='')


import random
import math
(n, k) = map(int, input().split())
if k > 26:
	k = 26
letters = 'abcdefghijklmnopqrstuvwxyz'
res = []
for i in range(n):
	res.append(letters[i % k])
print(''.join(res))


(n, k) = [int(x) for x in input().split()]
r = n // k
password = ''
for _ in range(r):
	for i in range(k):
		password += str(chr(ord('a') + i))
r = n % k
for i in range(r):
	password += str(chr(ord('a') + i))
print(password)


(n, k) = list(map(int, input().split()))
s = ''
for i in range(n):
	s += chr(i % k + 97)
print(s)


(n, k) = map(int, input().split())
s = ''
x = n // k
y = n % k
for i in range(x):
	for j in range(k):
		p = str(chr(97 + j))
		s = s + p
for i in range(y):
	p = str(chr(97 + i))
	s = s + p
print(s)


import string
(n, k) = map(int, input().split())
ans = ''
ans += string.ascii_lowercase[:k] * (n // k)
n = n - n // k * k
ans += string.ascii_lowercase[:n]
print(ans)


(n, k) = map(int, input().split())
l = 'abcdefghijklmnopqrstuvwxyz'
a = 0
for i in range(n):
	print(l[a], end='')
	a += 1
	if a == k:
		a = 0


(n, k) = map(int, input().split())
c = 'a'
l = list(map(chr, range(ord('a'), ord('a') + k)))
l = [x for x in l * (n // k)]
while len(l) < n:
	l.append(c)
	c = chr(ord(c) + 1)
print(''.join(l))


s = input().split(' ')
s[0] = int(s[0])
s[1] = int(s[1])
l = []
char = 97
while s[1]:
	l.append(char)
	char += 1
	s[1] -= 1
j = 0
for i in range(s[0]):
	if j == len(l):
		j = 0
	print(chr(l[j]), end='')
	j += 1
print()


n1 = input().split(' ')
n = int(n1[0])
k = int(n1[1])
alp = 'abcdefghijklmnopqrstuvwxyz'
s = ''
s1 = ''
s2 = ''
for i in range(k):
	s += alp[i]
s2 = s * (n - k)
for i in range(n - k):
	s1 += s2[i]
print(s + s1)


(a, b) = map(int, input().split())
l = 'abcdefghijklmnopqrstuvwxyz'
l1 = ''
for i in range(b):
	l1 += l[i]
for i in range(a):
	if i + 1 > b:
		i %= b
	print(l1[i], end='')


def password(n, k):
	cur = 97
	ans = ''
	while len(ans) != k:
		ans += chr(cur)
		cur += 1
		if cur == 123:
			cur = 97
	while len(ans) < n:
		ans += ans
	return ans[:n]
(n, k) = list(map(int, input().split()))
print(password(n, k))


inn = list(map(int, input().split(' ')))
lent = inn[0]
dist = inn[1]
lets = []
i = 97
for _ in range(dist):
	lets.append(chr(i))
	i += 1
passcd = ''.join(lets)
while len(passcd) < lent:
	passcd += passcd
print(passcd[:lent])


import sys
(n, k) = map(int, input().split())
alphabet = 'abcdefghijklmnopqrstuvwxyz'
res = alphabet[0:min(n, k)]
cnt = n - k
pos = 0
while cnt > 0:
	res += alphabet[pos]
	if pos < k - 1:
		pos += 1
	else:
		pos = 0
	cnt -= 1
print(res)


(n, k) = map(int, input().split())
password = ''
j = 0
for i in range(n):
	password += chr(j + 97)
	j = (j + 1) % k
print(password)


(n, k) = [int(i) for i in input().split()]
s = []
a = []
for i in range(ord('a'), ord('a') + k):
	s += [chr(i)]
x = n // k + 1
for i in range(x):
	a += s
print(*a[0:n], sep='')


import string
alphabet_string = string.ascii_lowercase
(n, k) = list(map(int, input().split(' ')))
ans = alphabet_string[:k]
print(ans * (n // k) + alphabet_string[:n % k])


(n, k) = map(int, input().split())
l = [chr(i + 97) for i in range(k)]
z = n // k * k
a = n // k
z1 = n - z
ans = l * a + l[0:z1]
print(''.join(ans))


(n, k) = map(int, input().split())
alpha = 'abcdefghijklmnopqrstuvwxyz'
repeat = (n - k) // k + 1
part = (n - k) % k
word = alpha[:k]
print(word * repeat + word[:part])


x = ['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']
(n, k) = list(map(int, input().split()))
while n > 0:
	for i in range(0, k):
		print(x[i], end='')
		n -= 1
		if n == 0:
			break
		else:
			continue


lst = []
(n, k) = list(map(int, input().split()))
i = 0
j = 0
while i < n:
	lst.append(chr(97 + j))
	limit = k - 1
	if j == limit:
		j = 0
	elif i == n:
		break
	else:
		j += 1
	i += 1
print(''.join(lst))


import string
(n, k) = (int(x) for x in input().split())
symbols = string.ascii_lowercase[0:k]
pwd = [symbols[i % len(symbols)] for i in range(n)]
print(*pwd, sep='')


(n, k) = map(int, input().split(' '))
alfa = 'abcdefghijklmnopqrstuvwxyz'
alphabet = []
for i in alfa:
	alphabet.append(i)
password = []
for i in range(k):
	password.append(alphabet[i])
for i in range(n - k):
	password.append(password[i])
for i in password:
	print(i, end='')


letters = [chr(i) for i in range(ord('a'), ord('z') + 1)]
(n, k) = map(int, input().split())
ans = ''
i = 0
while n > 0:
	j = 0
	while j < k and n > 0:
		ans += letters[j]
		j += 1
		n -= 1
print(ans)


x = input()
x = x.split()
a = int(x[0])
b = int(x[1])
s = ''
c = ord('a')
for i in range(a):
	if c - ord('a') < b:
		s += chr(c)
	else:
		c = ord('a')
		s += chr(c)
	c += 1
print(s)


(n, k) = map(int, input().split())
l = []
for i in range(97, 97 + k):
	l.append(chr(i))
if n == k:
	print(''.join(l))
else:
	g = ''
	for j in range(n):
		g += l[j % k]
	print(g)


import string

def main():
	(n, k) = [int(x) for x in input().split()]
	print((string.ascii_lowercase[:k] * 100)[:n])
main()


from math import ceil
(n, k) = input().split()
n = int(n)
k = int(k)
l = [chr(x) for x in range(ord('a'), ord('z') + 1)]
s = ''
S = ''
for i in range(k):
	s += l[i]
length = ceil(n / k)
for _ in range(length):
	S += s
print(S[:n])


def generate_password(n, k):
	alph = [chr(x) for x in range(ord('a'), ord('a') + k, 1)]
	password = ''
	j = 0
	for i in range(n):
		if j == len(alph):
			j = 0
		password += alph[j]
		j += 1
	return password
(n, k) = input().split()
n = int(n)
k = int(k)
pas = generate_password(n, k)
print(pas)


(n, k) = map(int, input().split())
temp = 'abcdefghijklmnopqrstuvwxyz'
fir = temp[:k]
s = fir
while len(s) < n:
	s += fir
s = s[:n]
print(s)


import math
(a, b) = [int(i) for i in input().split()]
f = 'abcdefghijklmnopqrstuvwxyz'
s = f[0:b]
d = math.floor(a / b)
s = s * d
e = abs(len(s) - a)
s = s + f[0:e]
print(s)


(n, k) = map(int, input().split())
alpha = 'abcdefghijklmnopqrstuvwxyz'
pas = []
for i in range(k):
	pas.append(alpha[i % 26])
for i in range(n - k):
	if i > k:
		pas.append(pas[i % k])
	else:
		pas.append(pas[i])
print(''.join(pas))


(n, k) = input().split()
n = int(n)
k = int(k)
s = 'abcdefghijklmnopqrstuvwxyz'
res = s[:k] * (n // k + 1)
print(res[:n])


(N, K) = map(int, input().split())
for i in range(N):
	print(chr(ord('a') + i % K), end='')
print()


(n, k) = list(map(int, input().split()))
k = [chr(i) for i in range(ord('a'), ord('a') + k)]
p = ''
c = 0
for i in range(n):
	if c == len(k):
		c = 0
	p += k[c]
	c += 1
print(p)


import string
(n, k) = map(int, input().split())
s = string.ascii_lowercase[:k]
a = n // k
s = s + s * a
print(s[:n])


(n, k) = input().split()
n = int(n)
k = int(k)
l = []
i = 0
flag = 0
while True:
	for j in range(1, k + 1):
		l.append(chr(j + 96))
		i += 1
		if i == n:
			flag = 0
			break
		else:
			flag = 1
	if flag == 0:
		break
print(''.join(l))


import string

def solve():
	(n, k) = map(int, input().split())
	chrs = string.ascii_letters
	print(n // k * chrs[:k] + chrs[:n % k])
solve()


t = input().split()
n = int(t[0])
k = int(t[1])
string = 'ab'
k1 = 2
num = 67
i = 0
while k1 != k:
	string += chr(num).lower()
	num += 1
	k1 += 1
while len(string) != n:
	string += string[i]
	i += 1
print(string)


w = input().split()
(n, k) = (int(w[0]), int(w[1]))
s = ''
for i in range(n):
	s += chr(ord('a') + i % k % 26)
print(s)


inp = input().split()
n = int(inp[0])
k = int(inp[1])
arr = []
ch = 'a'
for i in range(k):
	arr.append(ch)
	ch = chr(ord(ch) + 1)
s = ''
j = 0
for i in range(n):
	if j >= k:
		j = 0
	s = s + str(arr[j])
	j = j + 1
print(s)


import string
(n, k) = [int(x) for x in input().split()]
alphabet = string.ascii_lowercase
symbol = alphabet[:k]
if n == k:
	print(symbol)
elif n > k:
	s = symbol * (n // k)
	if len(s) != n:
		s += symbol[:n - len(s)]
	print(s)
else:
	s = symbol[:n]
	print(s)


d = [chr(i) for i in range(97, 123)]
(n, k) = map(int, input().split())
s = ''.join(map(str, d[:k]))
s = s * (n // k) + s[:n % k]
print(s)


lst = list(map(int, input().strip().split()))[:2]
n = lst[0]
k = lst[1]
unqstr = ''
for i in range(k):
	unqstr = unqstr + chr(97 + i)
n = n - k
password = unqstr
k = 0
for j in range(n):
	password = password + unqstr[k]
	k += 1
	if k == len(unqstr):
		k = 0
print(password)


(n, k) = list(map(int, input().split()))
result = ''
p = []
for i in range(97, 123):
	p.append(chr(i))
c = p[:k + 1]
j = 0
for i in range(n):
	result += p[j % k]
	j += 1
print(result)


import string
(n, k) = map(int, input().split())
alfabeto = string.ascii_lowercase
letras = [l for (i, l) in enumerate(alfabeto) if i < k]
ans = ''
for i in range(n):
	ans += letras[i % k]
print(ans)


string = input()
n = int(string.split(' ')[0])
k = int(string.split(' ')[1])
res = ''
possible = []
first_letter = 'a'
for i in range(k):
	possible.append(first_letter)
	first_letter = chr(ord(first_letter) + 1)
for i in range(n):
	res = res + str(possible[i % len(possible)])
print(res)


def NewPassword():
	(n, k) = map(int, input().strip().split())
	alpha = 'abcdefghijklmnopqrstuvwxyz'
	new_pass = ''
	for i in range(k):
		new_pass += alpha[i]
	i = 0
	j = k
	while n - j > 0:
		new_pass += alpha[i]
		i += 1
		j += 1
		if i >= k:
			i = 0
	return new_pass
a = NewPassword()
print(a)


def pas(l, d):
	ls = [chr(i) for i in range(97, 123)]
	s = ''.join(ls[0:d])
	s = s * (l // d + 1)
	s = s[0:l]
	print(s)
(l, d) = list(map(int, input().split()))
pas(l, d)


(n, k) = input().split()
n = int(n)
k = int(k)
lis = ['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']
password = ['0'] * n
dist = []
for i in range(k):
	dist.append(lis[i])
j = 0
for i in range(n):
	password.insert(i, dist[j])
	j += 1
	if j == len(dist):
		j = 0
for i in range(n):
	print(password[i], end='')


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	(n, m) = LI()
	s = 'abcdefghijklmnopqrstuvwxyz'
	x = s[:m]
	ans = x * 101
	return ans[:n]
print(main())


(n, k) = map(int, input().split())
char_list = list()
for i in range(k):
	char_list.append(chr(97 + i))
password = ''
flag = 1
while True:
	for j in range(k):
		password += char_list[j]
	if len(password) > n:
		password = password[:n]
		break
print(password)


def solution(l1):
	alfie = 'abcdefghijklmnopqrstuvwxyz'
	snippet = alfie[:l1[1]]
	c_out = (snippet * l1[0])[:l1[0]]
	return c_out

def answer():
	l1 = [int(x) for x in input().split()]
	print(solution(l1))
answer()


(n, k) = map(int, input().strip().split())
hashmap = list('abcdefghijklmnopqrstuvwxyz')
r2 = ''
for i in range(0, n):
	r2 += hashmap[i % k]
print(r2)


import string
letters = string.ascii_lowercase
d = input()
s = d.split()
n = int(s[0])
k = int(s[1])
p = ''
j = 0
letters = letters[0:k]
letters = letters * (200 // k)
while True:
	p += letters[j]
	c = len(p)
	j = j + 1
	if c == n:
		break
print(p)


s = ''
(n, k) = map(int, input().split())
for i in range(k):
	s += chr(97 + i)
remain_length = n - len(s)
if remain_length > 0:
	s += s * (remain_length // len(s))
add_length = n - len(s)
if add_length > 0:
	s += s[:add_length]
print(s)


(n, k) = map(int, input().split())
alfabet = []
s = ''
for x in range(k):
	alfabet.append(chr(97 + x))
for x in range(n):
	s += alfabet[x % k]
print(s)


(n, k) = map(int, input().split())
from string import ascii_lowercase as s
print(''.join((s[i % k] for i in range(n))))


import string
ALPHABETS = string.ascii_lowercase

def getNewPassword(n, k):
	newPassword = ''
	for i in range(n):
		newPassword += ALPHABETS[i % k]
	return newPassword
constrains = input().strip().split()
n = int(constrains[0])
k = int(constrains[1])
res = getNewPassword(n, k)
print(res)


import random
s = input()
s = s.split()
n = int(s[0])
k = int(s[1])
x = '1'
temp = 0
ut = ['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']
for i in range(n):
	if temp < k and ut[temp] != ut[temp - 1]:
		x += ut[temp]
		temp += 1
		if temp == 26:
			temp = 0
	else:
		bleh = 0
		while ut[bleh] == ut[temp]:
			bleh = random.randint(0, temp)
		x += ut[bleh]
		temp = bleh
		temp += 1
		if temp == 26:
			temp = 0
print(x[1:])


import string
(n, k) = input().split(' ')
my_str = ''
for i in range(0, int(k)):
	my_str += string.ascii_letters[i]
if k != '0':
	my_str *= int(n) // int(k)
	for i in range(0, int(n) % int(k)):
		my_str += string.ascii_letters[i]
else:
	my_str += 'a'
	my_str *= int(n)
print(my_str)


list1 = input().strip().split()
list2 = []
for i in range(int(list1[1])):
	list2.append(chr(97 + i))
s = ''
for i in range(int(list1[0])):
	s += list2[i % int(list1[1])]
print(s)


alph = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
letters = alph[:k]
print((letters * (n // k + 1))[:n])


(n, k) = map(int, input().split())
nxt = -1
for i in range(n):
	nxt += 1
	nxt %= k
	print(chr(nxt + 97), end='')


(n, k) = map(int, input().split())
words = [chr(i) for i in range(97, 97 + k)]
pwd = ''.join(words)
pwd = pwd * n
print(pwd[:n])


from string import ascii_lowercase
import random
(n, k) = [int(v) for v in input().split()]
print(''.join(ascii_lowercase[:k] * (n // k + 1))[:n])


(n, k) = input().split()
n = int(n)
k = int(k)
char_num = 1
while char_num <= n:
	for i in range(0, k):
		print(chr(ord('a') + i), end='')
		char_num += 1
		if char_num > n:
			break


from sys import stdin, stdout

def get_ints():
	return map(int, stdin.readline().strip().split())

def get_array():
	return list(map(int, stdin.readline().strip().split()))

def get_string():
	return stdin.readline().strip()
(n, k) = get_ints()
j = 97
s = ''
for i in range(n):
	if j - 97 < k:
		s += chr(j)
	else:
		j = 97
		s += chr(j)
	j += 1
print(s)


def main():
	(n, k) = map(int, input().split())
	res = ''
	for i in range(min(k, n)):
		res += chr(ord('a') + i)
	for i in range(k, n):
		res += res[i - k]
	print(res)
main()


i = list(map(int, input().split()))
n = i[0]
k = i[1]
l = []
for j in range(n):
	l.append(chr(97 + j % k))
print(''.join(l))


(n, k) = map(int, input().strip().split())
q = (n + k - 1) // k
s = ''
for i in range(q):
	for j in range(k):
		if len(s) < n:
			s += chr(ord('a') + j)
		else:
			break
print(s)


(X, Temp) = (list(map(int, input().split())), '')
for i in range(X[1]):
	Temp += chr(ord('a') + i)
print(Temp * (X[0] // X[1]) + Temp[:X[0] % X[1]])


(l, a) = input().split()
l = int(l)
alpha = int(a)
strt = ord('a')
password = ''
for i in range(l):
	if alpha >= l:
		password += chr(strt + i)
	else:
		password += chr(strt + i % alpha)
print(password)


(n, k) = map(int, input().split())
ans = ''
i = 96
j = 0
while len(ans) <= n:
	j += 1
	i += 1
	ans += chr(i)
	if j == k:
		i = i - k
		j = 0
print(ans[:n])


(n, d) = list(map(int, input().split()))
a = 'abcdefghijklmnopqrstuvwxyz'
w = ''
i = 0
while len(w) != n:
	if i == d:
		i = 0
		w += a[i]
	else:
		w += a[i]
	i += 1
print(w)


import string
u = input().split()
n = int(u[0])
k = int(u[1])
pw = string.ascii_lowercase
pww = ''
for i in range(k):
	pww = pww + pw[i]
strr = ''
for i in range(int(n / k)):
	strr = strr + pww
for i in range(n % k):
	strr = strr + pww[i]
print(strr)


import string
import math

def input_int():
	return list(map(int, input().split()))
alphabet = string.ascii_lowercase
[n, k] = input_int()
print((alphabet[:k] * math.ceil(n / k))[:n])


(n, k) = input().split()
n = int(n)
k = int(k)
answer = []
for i in range(k):
	answer += chr(ord('a') + i)
answer *= n // k
for i in range(n % k):
	answer += chr(ord('a') + i)
print(''.join(answer))


inp = input()
n = int(inp.split()[0])
k = int(inp.split()[1])
letters = 'abcdefghijklmnopqrstuvwxyz'
print(letters[:k] * (n // k) + letters[:n % k])


(n, k) = [int(i) for i in input().split()]
letters = 'abcdefghijklmnopqrstuvwxyz'
for i in range(n):
	print(letters[i % k], end='')


(n, k) = (int(x) for x in input().split())
pwd = [chr(ord('a') + i % k) for i in range(n)]
print(*pwd, sep='')


def buildPassword(n, k):
	passWord = ''
	for i in range(n):
		passWord += str(chr(97 + i % k))
	return passWord
(n, k) = [int(x) for x in input().split(' ')]
print(buildPassword(n, k))


(n, k) = map(int, input().split())
f = 0
ps = ''
for i in range(n):
	ps += chr(f % k + 97)
	f += 1
print(ps)


(a, b) = input().split(' ')
a = int(a)
b = int(b)
c = 'abcdefghijklmnopqrstuvwxyz'
d = []
i = 0
j = 0
while i < 26:
	d.append(c[i])
	i = i + 1
i = 0
k = 0
while i < a:
	if k == b:
		k = 0
	if i >= b and k != b:
		print(d[k], end='')
		k = k + 1
		i = i + 1
	while i < b:
		print(d[i], end='')
		i = i + 1


(n, d) = map(int, input().split())
l = []
for i in range(d):
	l.append(chr(97 + i))
for i in range(n - d):
	l.append(l[i])
print(''.join(l))


s = input().split()
dl = int(s[0])
k = int(s[1])
pred = 0
password = list()
e = 0
while True:
	for i in range(0, k):
		password.append(chr(i + 97))
		e += 1
		if e == dl:
			break
	if e == dl:
		break
print(''.join(map(str, password)))


alph = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
a = alph[:k]
s = 'a'
for i in range(1, n):
	s += alph[i % k]
print(s)


(n, k) = map(int, input().strip(' ').split())
lis = []
for i in range(k):
	lis.append(chr(97 + i))
	i = 0
while n > 0:
	if i == k:
		i = 0
	print(lis[i], end='')
	i += 1
	n -= 1


(n, k) = map(int, input().split())
abc = 'abcdefghijklmnopqrstuvwxyz'
f = abc[:k]
s = f
while len(s) < n:
	s += f
s = s[:n]
print(s)


import math
(n, m) = map(int, input().strip().split()[:2])
k = [chr(x) for x in range(97, 97 + m)]
p = ''.join(k)
p += p * math.ceil(n / m)
p = p[:n]
print(p)


password = ''
(n, k) = list(map(int, input().split()))
alph = [chr(i) for i in range(97, 97 + k)]
for i in range(n):
	password += alph[i % k]
print(password)


import string
(n, m) = map(int, input().split())
x = list(string.ascii_lowercase)
x = x[:m]
q = 0
password = ''
for i in range(n):
	password = password + x[q]
	q = q + 1
	if q == m:
		q = 0
print(password)


(n, k) = map(int, input().split())
print(('abcdefghijklmnopqrstuvwxyz'[0:k] * ((n + k - 1) // k))[0:n])


import math
(length, distinct) = map(int, input().split())
r = math.ceil(length / distinct)
str1 = ''
for x in range(97, 97 + distinct):
	str1 += chr(x)
str2 = str1 * r
print(str2[:length])


(n, k) = map(int, input().split())
seq = [chr(97 + i) for i in range(k)]
p = -1
for i in range(n):
	p = p + 1 if p < k - 1 else 0
	print(seq[p], end='')
print()


import random as rand
li = []
for i in range(0, 26):
	x = chr(97 + i)
	li.append(x)
(n, k) = map(int, input().split(' '))
sub1 = li[:k]
sub1 = sub1 * (n // k)
sub2 = sub1[:n % k]
ans = sub1 + sub2
for i in range(0, len(ans)):
	print(ans[i], end='')


import random
L = input().split(' ')
n = int(L[0])
k = int(L[1])
password = ''
a = 0
for i in range(n):
	password += chr(97 + a)
	a = (a + 1) % k
print(password)


alph = 'abcdefghijklmnopqrstuvwxyz'
(n, k) = map(int, input().split())
c = alph[:k]
i = 0
while len(c) < n:
	c += c[i]
	i += 1
print(c)


(n, k) = map(int, input().split())
i = 1
ii = 1
kek = ''
while i <= n:
	if ii == k:
		kek += chr(96 + ii)
		ii = 1
	else:
		kek += chr(96 + ii)
		ii += 1
	i += 1
print(kek)


(n, k) = map(int, input().split())
l = []
w = []
for i in range(k):
	l.append(chr(97 + i))
for i in range(n):
	w.append(''.join(l))
q = ''.join(w)
print(q[:n])


s = 'abcdefghijklmnopqrstuvwxyz'
lt = list(input().split())
(n, k) = (int(lt[0]), int(lt[1]))
s = s[:k]
s = s * (n // k)
s += s[:n % k]
print(s)


x = 'abcdefghijklmnopqrstuvwxyz'
y = ''
cnt = 0
(a, b) = map(int, input().split())
y += x[0:b] * (a // b)
y += x[0:a % b]
print(y)


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return [int(i) for i in input().split()]

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
s = ''
(n, k) = mi()
for i in range(n):
	s += chr(ORDA + i % k)
print(s)


(n, k) = map(int, input().split())
s = ''
o = ord('a')
p = 0
for i in range(n):
	s += chr(o + p)
	if p < k - 1:
		p += 1
	else:
		p = 0
print(s)


(n, k) = [int(n) for n in input().split()]
s = 'abcdefghijklmnopqrstuvwxyz'
p = s[0:k]
q = p * n
print(q[0:n])


(lambda n, k: print(*([chr(i + ord('a')) for i in range(k)] * (n // k + 1))[:n], sep=''))(*map(int, input().split()))


(a, b) = map(int, input().split())
d = 'abcdefghijklmnopqrstuvwxyz'
l = d[0:b]
k = ''
t = 0
while len(k) != a:
	if t < b:
		k += l[t]
		t += 1
	elif t >= b:
		t = 0
print(k)


import string
(n, k) = map(int, input().split())
symbs = []
letters = string.ascii_lowercase[:k]
last = 0
for i in range(n):
	symbs.append(letters[last])
	last += 1
	if last == k:
		last = 0
print(''.join(symbs))


(n, k) = list(map(int, input().split()))
s = 'abcdefghijklmnopqrstuvwxyz'
need = s[:k]
result = ''
for i in range(n):
	result += need[i % len(need)]
print(result)


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']
(x, y) = input().split()
n = int(x)
m = int(y)
string = ''
if n == m:
	for i in range(0, n):
		string = string + a[i]
else:
	rounds = int(n / m)
	rounds2 = n % m
	for i in range(0, rounds):
		for j in range(0, m):
			string = string + a[j]
	for i in range(0, rounds2):
		string = string + a[i]
print(string)


from string import ascii_lowercase
from random import randint
(n, k) = map(int, input().split())
password = ''
start = 0
for _ in range(n):
	if start >= k:
		start = 0
	password += ascii_lowercase[start]
	start += 1
print(password)


import string
alphabet = string.ascii_lowercase
(n, k) = map(int, input().split())
le = min(k, 26)
index = 0
result = ''
for i in range(1, n + 1):
	result += alphabet[int(index)]
	index += 1
	if index >= k:
		index = 0
print(result)


import random
(n, m) = map(int, input().split())
z = 'abcdefghijklmnopqrstuvwxyz'
for i in range(n):
	print(z[i % m], end='')


from sys import stdin, stdout
from math import gcd, sqrt, floor, ceil
input = stdin.readline

def list_inp(x):
	return list(map(x, input().split()))

def map_inp(x):
	return map(x, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
s1 = 'abcdefghijklmnopqrstuvwxyz'
(a, b) = map_inp(int)
q = s1[:b]
q1 = q * a
print(q1[:a])


(n, k) = tuple(map(int, input('').split(' ')))
pan = 'abcdefghijklmnopqrstuvwxyz'
res = ''
while len(res) < n:
	res += pan[0:k]
print(res[0:n])


z = [int(el) for el in input().split()]
k = z[1]
n = z[0]
res = ''
to_use = [chr(i) for i in range(65 + 32, 65 + 32 + k)]
i = 0
while not len(res) == n:
	res += to_use[i]
	i = int((i + 1) % len(to_use))
print(res)


(n, k) = map(int, input().split())
p = ''
x = ord('a')
for i in range(k):
	p += chr(x)
	x += 1
ans = ''
for i in range(n):
	ans += p[i % k]
print(ans)


(n, k) = map(int, input().split())
A = [chr(i) for i in range(ord('a'), ord('z') + 1)]
for i in range(n):
	print(A[i % k], end='')
print()


import string
l = string.ascii_letters
(n, k) = map(int, input().split())
total = ''
for i in range(k):
	total += l[i]
c = 0
for j in range(n - k):
	if c == k:
		c = 0
		total += l[c]
		c += 1
	else:
		total += l[c]
		c += 1
print(total)


(n, k) = [int(x) for x in input().split()]
s = 'a'
letter_ind = 0
letter = 'a'
while len(s) < n:
	letter = chr((letter_ind + 1) % k + 97)
	s += letter
	letter_ind += 1
print(s)


import string
from math import trunc
a = list(map(int, input().split()))
length = a[0]
distinct = a[1]
alpha = string.ascii_lowercase
out = alpha[0:distinct]
times = trunc(length / distinct)
for i in range(times):
	print(out, end='')
rest = length - times * distinct
print(out[0:rest])


def main():
	(password_length, ndistinct_letters) = map(int, input().split())

	def new_password(password_length, ndistinct_letters):
		distinct_letters = [chr(letter) for letter in range(ord('a'), ord('a') + ndistinct_letters)]
		(password, current_index) = ('', 0)
		while len(password) < password_length:
			if current_index == len(distinct_letters):
				current_index = 0
			password += distinct_letters[current_index]
			current_index += 1
		return password
	print(new_password(password_length, ndistinct_letters))
main()


from sys import stdin
(n, k) = map(int, stdin.readline().rstrip().split())
m = n
while m > 0:
	print(chr(ord('a') + (n - m) % k), end='')
	m -= 1


(n, k) = map(int, input().split())
a = 'abcdefghijklmnopqrstuvwxyz'
b = a[0:k]
i = 0
while n != len(b):
	b = b + b[i]
	i += 1
	if i == k:
		i = 0
print(b)


dictionary = {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e', 6: 'f', 7: 'g', 8: 'h', 9: 'i', 10: 'j', 11: 'k', 12: 'l', 13: 'm', 14: 'n', 15: 'o', 16: 'p', 17: 'q', 18: 'r', 19: 's', 20: 't', 21: 'u', 22: 'v', 23: 'w', 24: 'x', 25: 'y', 26: 'z'}
(n, distinct) = list(map(int, input().split()))
count = 0
st = ''
for i in range(distinct):
	st += dictionary[i + 1]
st2 = ''
for _ in range(n):
	st2 += st[count]
	count += 1
	if count > distinct - 1:
		count = 0
print(st2)


(n, k) = [int(c) for c in input().split(' ')]
aCode = ord('a')
(passwd, temp) = ('', '')
for i in range(0, k):
	temp += chr(aCode + i)
count = n // k
rest = n % k
passwd = temp * count
if rest > 0:
	passwd += temp[:rest]
print(passwd)


import string
(n, k) = map(int, input().split())
print(string.ascii_letters[:k] * (n // k) + string.ascii_letters[:n % k])


(n, k) = map(int, input().split())
alfabeto = ['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']
resp = ''
for i in range(k):
	resp += alfabeto[i]
repeticao = len(resp)
j = 0
acabar = n - repeticao
while acabar != 0:
	resp += alfabeto[j]
	j += 1
	if j > k - 1:
		j = 0
	acabar -= 1
for j in range(n - len(resp)):
	resp += alfabeto[j]
print(resp)


(n, k) = map(int, input().split())
password = ''
let = 'abcdefghijklmnopqrstuvwxyz'
lis = list(let[:k])
i = 0
while i < n:
	if i > len(lis) - 1:
		password += lis[i % len(lis)]
		i += 1
		continue
	password += lis[i]
	i += 1
print(password)


(n, k) = [int(i) for i in input().split()]
pattern = [chr(i) for i in range(ord('a'), ord('a') + k)]
num = n // len(pattern)
print(''.join(pattern) * num + ''.join(pattern[:n - num * len(pattern)]))


(a, b) = map(int, input().split())
l = 'abcdefghijklmnopqrstuvwxyz'
s = l[:b]
u = a // b
s = s * u
r = a - b * u
s = s + l[:r]
print(s)


(n, k) = map(int, input().split())
t = 0
while t != n:
	c = 97
	for j in range(k):
		print(chr(c), end='')
		c += 1
		t += 1
		if t == n:
			break


(nx, kx) = input().split()
n = int(nx)
k = int(kx)
word = []
letters = list('abcdefghijklmnopqrstuvwxyz ')
for i in range(k):
	word.append(letters[i])
i = 0
while n > len(word):
	word.append(word[i])
	i += 1
print(''.join(word))


import string
l = list(string.ascii_lowercase)
st1 = ''.join(l)
(n, k) = input().split()
n = int(n)
k = int(k)
temp = st1[:k]
count = 0
while len(temp) < n:
	temp = temp + st1[count]
	if count < k - 1:
		count = count + 1
	else:
		count = 0
print(temp)


(n, k) = input().split()
n = int(n)
k = int(k)
Alpha = 'abcdefghijklmnopqrstuvwxyz'
res = Alpha[0:k]
i = 0
while n != len(res):
	res = res + res[i]
	i = i + 1
	if i == k:
		i = 0
print(res)


(n, k) = map(int, input().split())
z = 0
s = ''
for i in range(n):
	s += chr(z + 97)
	if z < k - 1:
		z += 1
	else:
		z = 0
print(s)


(n, k) = map(int, input().strip().split(' '))
s = ''
k += 97
for i in range(97, k):
	s += chr(i)
s = n * s
for i in range(n):
	print(s[i], end='')


(n, k) = list(map(int, input().split()))
for i in range(n):
	print(chr(ord('a') + i % k), end='')


(n, k) = input().split()
(n, k) = (int(n), int(k))
a = 'abcdefghijklmnopqrstuvwxyz'
s = []
for i in range(n):
	s.append(a[i % k])
s = ''.join(s)
print(s)


(n, k) = map(int, input().split())
r = n - k
distinct = []
password = []
alphapet = []
for i in range(97, 123):
	alphapet.append(chr(i))
for m in range(k):
	distinct.append(alphapet[m])
if n == k:
	print(''.join(distinct))
else:
	password = distinct
	for l in range(r):
		password.append(distinct[l])
print(''.join(password))


(n, k) = map(int, input().split())
alp = []
for i in range(k):
	alp.append(chr(97 + i))
ans = ''
for i in range(n):
	ans += alp[i % len(alp)]
print(ans)


import sys
(n, k) = map(int, input().split())
ss = [chr(x) for x in range(ord('a'), ord('a') + k)]
s = ''
while len(s) < n:
	s += ''.join(ss)
print(s[:n])