Problem: 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

Solution (in PYTHON3):

Solution:
import sys
from collections import deque #Counter
#sys.setrecursionlimit(20000)


def rl():
    return sys.stdin.readline().strip()
def rl_types(types):
    str_list = [x for x in sys.stdin.readline().strip().split(' ')]
    return [types[i](str_list[i]) for i in range(len(str_list))]

def pr( something ):
    sys.stdout.write( str(something) + '\n')
def pra( array ):
    sys.stdout.write( ' '.join([str(x) for x in array]) + '\n')


def solve(array):
    return array


def plausible_ordering(k):
    letters = [chr(ord('a')+i) for i in range(k)]
    edges = {}
    for i in letters:
        for j in letters:
            edges[i+j] = [j+c for c in letters]

    start = 'aa'
    end   = letters[-1]+'a'
    #print(edges)

    # now find a path from start to end
    # longest path will be 26^2, so stack okay
    def find_path(so_far_set,last,edges,goal):
        neighbs = edges[last]
        for n in [c for c in neighbs if not c in so_far_set]:
            so_far_set.add(n)
            if n == goal and len(so_far_set) == len(edges):
                return deque([goal])

            res = find_path(so_far_set,n,edges,goal)
            if res:
                res.appendleft(n)
                return res
            so_far_set.remove(n)
        return None


    ordering = find_path(set([start]),start,edges,end)
    ordering.appendleft(start)

    return ''.join([a[0] for a in ordering])

if __name__ == '__main__':

    n,k = [int(x) for x in rl().split(' ')]
    #pr(f'{n} {k}')

    if k==1:
        result = 'a'*n
    else:
        order = plausible_ordering(k)
        olen = len(order) # will be k^2
        result = order*(n//olen + 1)
        result = result[:n]
    pr(result)