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,functools,collections,bisect,math,heapq
import os
from io import BytesIO, IOBase
from types import GeneratorType
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")

## start here ##

#t = int(input())

alpha = 'abcdefghijklmnopqrstuvwxyz'
for _ in range(1):
    n,k = map(int,input().strip().split())
    d = collections.defaultdict(collections.deque)
    for i in range(k):
        for j in range(k):
            d[alpha[i]].append(alpha[j])
            
    cng = {}
    for i in range(k-1):
        cng[alpha[i]] = alpha[i+1]
    cng[alpha[k-1]] = 'a'
    
    ans = ['a']
    while d[ans[-1]]:
        for x in d[ans[-1]]:
            if len(d[x]) > 0:
                d[ans[-1]].remove(x)
                ans.append(x)
                break
        else:
            temp = d[ans[-1]].pop()
            ans.append(temp)
    
    while len(ans) < n:
        ele = k**2
        curr = len(ans)-ele        
        while ele:
            ans.append(ans[curr])
            curr += 1
            ele -= 1
            if len(ans) == n:
                break
    
    
    print(''.join(ans[i] for i in range(n)))