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 java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class CodeForces extends Functions {
    public static void  solve(){
        int n = sc.nextInt();
        int k = sc.nextInt();
        StringBuilder sb = new StringBuilder();
        for(char x = 'a';x<'a'+k;x++){
            for(char y = x;y<'a'+k;y++){
                sb.append(x);
                if(x!=y)sb.append(y);
            }
        }
        StringBuilder sb2= new StringBuilder();
        for(int i=0;i<n;i++)
            sb2.append(sb.charAt(i%sb.length()));
        System.out.println(sb2);

    }
/*
#include <bits/stdc++.h>
using namespace std;
int main(){
	int n,k;
	scanf("%d%d",&n,&k);
	string s="";
	for(int i=0;i<k;i++){
		for(int j=i;j<k;j++){
			s+='a'+i;
			if(j!=i)s+='a'+j;
		}
	}
	for(int i=0;i<n;i++)printf("%c",s[i%s.size()]);
}


void solve(int k) {
	a.push_back(k);
	if (k == 1) return;
	for (int i = 1; i < k - 1; ++i) {
		a.push_back(i); a.push_back(k);
	}
	a.push_back(k - 1);
	solve(k - 1);
	a.push_back(k);
}

int main() {
	scanf("%d%d", &n, &k);
	a.push_back(k);
	solve(k);
	if (k != 1) a.pop_back();
	for (int i = 0; i < n; ++i)
		printf("%c", a[i % (int)a.size()] + 'a' - 1);
}
 */



    public static void main(String[] args) {
        long start = System.currentTimeMillis();
        int testCase = 1;
//        testCase= sc.nextInt();
        while (testCase-->0){
            solve();
        }
        long end = System.currentTimeMillis();
//        System.out.println("time took in ms : "+(end-start));
    }
    static Scanner sc = new Scanner();

}

class Functions {
    public static int mod = (int)1e9+7;
    public static int INT_MAX = Integer.MAX_VALUE;
    public static int INT_MIN = Integer.MIN_VALUE;
    public static long LONG_MAX = Long.MAX_VALUE;
    public static long LONG_MIN = Long.MIN_VALUE;
    public static double DOUBLE_MAX = Double.MAX_VALUE;
    public static double DOUBLE_MIN = Double.MIN_VALUE;

    public static void sort(int[] a,boolean isAscending){
        ArrayList<Integer> temp = new ArrayList<>();
        for (int j : a) temp.add(j);
        sort(temp,isAscending);
        for(int i=0;i<a.length;i++)a[i] = temp.get(i);
    }
    public static void sort(List T,boolean isAscending){
        if(isAscending)
            Collections.sort(T);
        else Collections.sort(T,Collections.reverseOrder());
    }
    public static long factorial(int n){
        long fact = 1L;
        for(int i=2;i<=n;i++)fact = (fact*i)%mod;
        return fact;
    }

    public  static int ncr(int n, int r){
        // time O(n+r)
        if (r > n)
            return 0;
        long[] inv = new long[r + 1];
        inv[1] = 1;
        // Getting the modular inversion
        // for all the numbers
        // from 2 to r with respect to m
        for (int i = 2; i <= r; i++) {
            inv[i] = mod - (mod / i) * inv[(int) (mod % i)] % mod;
        }
        int ans = 1;
        // for 1/(r!) part
        for (int i = 2; i <= r; i++) {
            ans = (int) (((ans % mod) * (inv[i] % mod)) % mod);
        }
        // for (n)*(n-1)*(n-2)*...*(n-r+1) part
        for (int i = n; i >= (n - r + 1); i--) {
            ans = (int) (((ans % mod) * (i % mod)) % mod);
        }
        return ans;
    }

    public static void reverseArray(int[] a){
        int left = 0;
        int right = a.length-1;
        while (left<right){
            int temp =a[left];
            a[left] = a[right];
            a[right] = temp;
            left++;
            right--;
        }
    }
    public static long isPrime(int n){
        for(long i=2;i*i<=n;i++)
            if(n%i==0)return i;
        return -1;
    }
    public static long gcd(long a, long b) {
        // time O(loga + logb)
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
}

class Scanner {
    private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private StringTokenizer st = new StringTokenizer("");
    public String next(){
        while (!st.hasMoreTokens())
            try {
                st = new StringTokenizer(br.readLine());
            }catch (IOException e){
                e.printStackTrace();
            }
        return st.nextToken();

    }
    public int nextInt(){return Integer.parseInt(next());}
    public long nextLong(){return Long.parseLong(next());}
    public double nextDouble(){return Double.parseDouble(next());}
    public int[] setIntArray(int n){
        int[] arr =new int[n];
        for(int i=0;i<n;i++)arr[i] = nextInt();
        return arr;
    }
    public Integer[] setIntegerArray(int n){
        Integer[] arr =new Integer[n];
        for(int i=0;i<n;i++)arr[i] = nextInt();
        return arr;
    }
    public long[] setlongArray(int n){
        long[] arr =new long[n];
        for(int i=0;i<n;i++)arr[i] = nextLong();
        return arr;
    }
    public int[][] set2DIntegerMatrix(int row,int col){
        int[][] arr = new int[row][col];
        for(int i=0;i<row;i++)
            for(int j= 0;j<col;j++)
                arr[i][j] = nextInt();
        return arr;
    }
}
