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 JAVA):

Solution:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.function.BiConsumer;

import java.io.IOException;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;

public class S2 {
	
	static class Reader {
		
		static BufferedReader reader;
		static StringTokenizer tokenizer;
		
		static void init(InputStream input) {
			reader = new BufferedReader(new InputStreamReader(input));
			tokenizer = new StringTokenizer("");
		}
		
		static String next() throws IOException {
			while(!tokenizer.hasMoreTokens()) {
				tokenizer = new StringTokenizer(reader.readLine());
			}
			return tokenizer.nextToken();
		}
		
		static int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
		
		static long nextLong() throws IOException {
			return Long.parseLong(next());
		}
		
	}
	
	static int[] merge(int[] a, int[] b) {
		int m = a.length;
		int n = b.length;
		int [] c = new int[n+m];
		
		int j=0, k=0;
		while(j+k<m+n) {
			if(j>=m) {
				c[j+k] = b[k];
				k++;
			}
			else if(k>=n) {
				c[j+k] = a[j];
				j++;
			}
			else {
				if(a[j]<b[k]) {
					c[j+k] = a[j];
					j++;
				}
				else if(a[j]==b[k]) {
					if(a[j]<b[k]) {
						c[j+k] = a[j];
						j++;
					}
					else {
						c[j+k] = b[k];
						k++;
					}
				}
				else {
					c[j+k] = b[k];
					k++;
				}
			}
		}
		return c;
	}
	
	static int[] Msort(int[] unsorted){
		int l = unsorted.length;
		
		if(l<=1) {
			return unsorted;
		}
		
		else {
			int[] Msorted = new int[l];
			int[] m1 = new int[l/2];
			int[] m2 = new int[l-(l/2)];
			
			for(int i=0; i<l; i++) {
				if(i<l/2) {
					m1[i] = unsorted[i];
				}
				else {
					m2[i-(l/2)] = unsorted[i];
				}
			}
			
			Msorted = merge(Msort(m1), Msort(m2));		
			
			return Msorted;
		}
		
	}
	
	private static int inf = 1<<27;
	private static long ans;
	private static int n;
	private static int k;
	private static int[] arr;
	
	public static void main(String[] args) throws IOException {
				
		ans = 0;
		
		Reader.init(System.in);
		
		OutputStream out = new BufferedOutputStream(System.out);
		
		int t=1;
	//	t = Reader.nextInt();
		
		main_loop:
		for(int tn=0; tn<t; tn++) {
			
			ans=0;
			n=0;
			n = Reader.nextInt();
			k = Reader.nextInt();
			
			boolean bruh = true;
			ans=1;
			it:
			while(bruh) {
				char ch='a';
				for(int i=0; i<k-1; i++) {
					if(ans>n)
						break it;
					ans++;
					ch=(char)((int)'a'+i);
					out.write((ch+"").getBytes());
					for(int j=i+1; j<k; j++) {
						if(ans>n)
							break it;
						ans++;
						ch=(char)((int)'a'+i);
						out.write((ch+"").getBytes());
						
						if(ans>n)
							break it;
						ans++;
						ch=(char)((int)'a'+j);
						out.write((ch+"").getBytes());
					}
				}
				if(ans>n)
					break it;
				ans++;
				ch=(char)((int)'a'+k-1);
				out.write((ch+"").getBytes());
			}

			
		//	out.write(("YES\n").getBytes());
		//	out.write(("NO\n").getBytes());
		//	out.write((ans+"\n").getBytes());
			
		}
		
		out.flush();
		out.close();
		
	}

}