Let's define the cost of a string s as the number of index pairs i and j (1 ≤ i < j < |s|) such that s_i = s_j and s_{i+1} = s_{j+1}.

You are given two positive integers n and k. Among all strings with length n that contain only the first k characters of the Latin alphabet, find a string with minimum possible cost. If there are multiple such strings with minimum cost — find any of them.

Input

The only line contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5; 1 ≤ k ≤ 26).

Output

Print the string s such that it consists of n characters, each its character is one of the k first Latin letters, and it has the minimum possible cost among all these strings. If there are multiple such strings — print any of them.

Examples

Input


9 4


Output


aabacadbb


Input


5 1


Output


aaaaa

Input


10 26


Output


codeforces
import math

# import operator as op 
# from functools import reduce
# from collections import defaultdict
# from math import comb # n! / (k! * (n - k)!)
# from sys import stdout

NO = 'NO'
YES = 'YES'
MOD = 1000000007
ALPH = 'abcdefghijklmnopqrstuvwxyz'
 
def input_int():
    return int(input())
 
def input_list():
    return input().split(' ')
 
def input_list_int():
    return list(map(int, input_list()))
 
def z_func(s):
    n = len(s)
    z = [0] * n
    l = r = 0
    for i in range(1, n):
        if r >= i:
            z[i] = min(z[i - l], r - i + 1)
        while z[i] + i < n and s[z[i]] == s[z[i] + i]:
            z[i] += 1
        if i + z[i] - 1 > r:
            l = i
            r = i + z[i] - 15
    return z
 
 
global_ans = []
def pr(a):
    global_ans.append(a)


def calc(s):
    l = len(s)
    ans = 0
    for i in range(l):
        for j in range(i + 1, l):
            if j + 1 < l and s[i] == s[j] and s[i + 1] == s[j + 1]:
                ans += 1
    print(ans)

def solve():
    n, k = input_list_int()
    tmp = {}
    tmp_idx = {} 
    alph = ALPH[0:k]
    for i in range(k):
        w = ALPH[i]
        tmp[w] = alph
        tmp_idx[w] = i

    ans = 'a'
    last = 'a'
    for i in range(n - 1):
        nxt = tmp[last][tmp_idx[last]]
        tmp_idx[last] += 1
        if tmp_idx[last] >= k:
            tmp_idx[last] = 0
        ans += nxt
        last = nxt
    pr(ans)
    # calc(ans)

query_count = 1
# query_count = input_int()

# print('a' < 'b')
while query_count:
    query_count -= 1
    solve()
for global_ans_line in global_ans:
    print(global_ans_line)