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.DataInputStream; 
	import java.io.FileInputStream; 
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.util.*;
	
	
	// always remeber trees mein edges are undirecred, all componenets are connected and the graph is acyclic
	
	
	
	
	
public class Main{
	



	static void sort(long[] diff,int[] idx,int start,int end) {
		
		if(start>=end) return;
		
		
		int mid=(start+end)>>>1;
		
		sort(diff,idx,start,mid);
		sort(diff,idx,mid+1,end);
		
		long td[]=new long[end-start+1];
		
		int ti[]=new int[end-start+1];
		
		int i=start,j=mid+1;int ptr=-1;
		
		while(i<=mid && j<=end) {
			
			if(diff[i]<=diff[j]) {
				
				td[ptr+1]=diff[i];
				ti[++ptr]=idx[i++];
			}
			
			else {
				
				td[ptr+1]=diff[j];
				ti[++ptr]=idx[j++];
			}
			
		}
			
			while(i<=mid) {
				td[ptr+1]=diff[i];
				ti[++ptr]=idx[i++];

				
			}
			
			while(j<=end) {
				td[ptr+1]=diff[j];
				ti[++ptr]=idx[j++];

			}
			
			
		
		
		for(int x=start;x<=end;x++) {
			
			diff[x]=td[x-start];
			idx[x]=ti[x-start];
		}
	}
		
		
	public static void main (String[] args) throws IOException
	{	
			r.init(System.in);
			PrintWriter o=new PrintWriter(System.out);
			
			int n=r.i();
			
			int k=r.i();
			
			
			String s="a"; char x='a';char y='b';
			
			while(s.length()<k*k) {
				//System.out.println(s);
				s+=x;
				s+=y;
				y+=1;
				
				if(y-'a'==k) {
					x+=1;
					s+=x;
					y=(char)(x+1);
				}
			}
			
			String temp=s.substring(0,s.length());
			
			if(n<=k*k){
				System.out.println(s.substring(0,n));
				return;
			}
			
			int g= n/(k*k);
			
			while(s.length()<n) {
				
				s+=s;
			}
			
			System.out.println(s.substring(0,n));
	}
}
	
	
	
	
	class r {
	    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() ) {
	            //TODO add check for eof if necessary
	            tokenizer = new StringTokenizer(
	                   reader.readLine() );
	        }
	        return tokenizer.nextToken();
	    }
	
	    static int i() throws IOException {
	        return Integer.parseInt( next() );
	    }
	    
	    static long l() throws IOException {
	        return Long.parseLong( next() );
	    }
	    
	    static double d() throws IOException {
	        return Double.parseDouble( next() );
	    }
	    
	}