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.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger; 
//import javafx.util.*; 
public final class B
{    
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<ArrayList<Integer>> g,CARS,intersection;	
	static long mod=1000000007;
	static int D1[],D2[],par[];
	//	static boolean set[];
	static long INF=Long.MAX_VALUE;
	static long dp_R[][],dp_L[][];
	static boolean found=false;
	static ArrayList<Integer> A=new ArrayList<>();
	static int x=0;
	public static void main(String args[])throws IOException
	{  	
		int N=i(),K=i();
		boolean set[][]=new boolean[K][K];
		int row=0,col=0,size=0;
		if(K==1)
		{
			for(int i=0; i<N; i++)ans.append('a');
			System.out.println(ans);
			return;
		}
		for(int i='a'; i<='a'+(K-1); i++)
		{
			ans.append((char)i);
			for(int j=i+1; j<='a'+(K-1); j++)
			{
				ans.append((char)i);
				ans.append((char)j);
				
			}
		}
		StringBuilder sb=new StringBuilder();
		int n=N/ans.length();
		while(n-->0)sb.append(ans);
		n=N%ans.length();sb.append(ans.substring(0,n));
		System.out.println(sb);
		
	}
	static int index(char X[],int l)
	{

		for(int i=X.length-1; i>l; i++)
		{
			if(X[i]!='9')return i;
		}
		return -1;
	}
	static long pre(char X[],int l)
	{
		long n=0;
		for(int i=0; i<l; i++)
		{
			int a=X[i]-'0';
			n=n*10+a;
		}
		return n;
	}
	static long f(long A[],long B[])
	{
		long x1=Math.max(A[0], B[0]),y1=Math.max(A[1], B[1]);
		long x2=Math.min(A[2], B[2]),y2=Math.min(A[3], B[3]);
		if(x1>x2 || y1>y2)
			return 0;
		x2-=x1;
		y2-=y1;
		return x2*y2;
	}
	static long f1(long A[],long B[],long C[])
	{
		long X[]=new long[4];
		long Y[]=new long[4];
		X[0]=Math.max(A[0], B[0]);X[1]=Math.max(A[1], B[1]);
		X[2]=Math.min(A[2], B[2]);X[3]=Math.min(A[3], B[3]);
		Y[0]=Math.max(A[0], C[0]);Y[1]=Math.max(A[1], C[1]);
		Y[2]=Math.min(A[2], C[2]);Y[3]=Math.min(A[3], C[3]);
		return f(X,Y);
	}
	static int pre(char X[])
	{
		for(int i=0; i<X.length; i++)if(X[i]=='*')return i;
		return -1;
	}
	static boolean f(long gcd)
	{
		while(gcd%3==0)gcd/=3;
		if((gcd &(gcd-1))==0)return true;
		else return false;

	}
	static boolean isValid(char X[],int l,int N)
	{
		int r=N-l; r--;
		//System.out.println(l+" "+r);
		if(r>=(l+1))
		{
			for(int i=0; i<=l; i++)
			{
				if(X[i]!=X[i+l+1])return false;
			}
			return true;
		}
		return false;
	}
	static boolean ispalin(char X[],int l,int r)
	{
		while(l<r)
		{
			if(X[l]!=X[r])return false;
			l++; r--;
		}
		return true;
	}

	static long min(long a,long b,long c)
	{
		return Math.min(a, Math.min(c, b));
	}

	static void print(int a)
	{
		System.out.println("! "+a);
	}
	static int ask(int a,int b)
	{
		System.out.println("? "+a+" "+b);
		return i();
	}
	static int find(int a)
	{
		if(par[a]<0)return a;
		return par[a]=find(par[a]);
	}
	static void union(int a,int b)
	{
		a=find(a);
		b=find(b);
		if(a!=b)
		{
			par[a]+=par[b]; //transfers the size
			par[b]=a;       //changes the parent
		}
	}
	static ArrayList<Integer> IND(int B[],HashMap<Integer,Integer> mp)
	{
		ArrayList<Integer> A=new ArrayList<>();
		for(int i:B)
		{
			if(mp.containsKey(i))
			{
				A.add(i);
				int f=mp.get(i)-1;
				if(f==0)
					mp.remove(i);
				else mp.put(i, f);		
			}
		}
		return A;
	}
	static HashMap<Integer,Integer> hash(int A[],int index)
	{
		HashMap<Integer,Integer> mp=new HashMap<Integer,Integer>();
		for(int i=index; i<A.length; i++)
		{
			int f=mp.getOrDefault(A[i], 0)+1;
			mp.put(A[i], f);
		}
		return mp;
	}
	static void swap(char A[],int a,int b)
	{
		char ch=A[a];
		A[a]=A[b];
		A[b]=ch;
	}

	static long lower_Bound(long A[],int low,int high, long x) 
	{ 
		if (low > high) 
			if (x >= A[high]) 
				return A[high]; 

		int mid = (low + high) / 2; 

		if (A[mid] == x) 
			return A[mid]; 

		if (mid > 0 && A[mid - 1] <= x && x < A[mid]) 
			return A[mid - 1]; 

		if (x < A[mid]) 
			return lower_Bound( A, low, mid - 1, x); 

		return lower_Bound(A, mid + 1, high, x); 
	} 
	static void sort(long[] a) //check for long
	{
		ArrayList<Long> l=new ArrayList<>();
		for (long i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}
	static void setGraph(int N)
	{
		g=new ArrayList<ArrayList<Integer>>();
		intersection=new ArrayList<ArrayList<Integer>>();
		CARS=new ArrayList<ArrayList<Integer>>();
		for(int i=0; i<=N; i++)
		{
			CARS.add(new ArrayList<Integer>());
			intersection.add(new ArrayList<Integer>());
			g.add(new ArrayList<Integer>());

		}
	}

	static  long pow(long a,long b)
	{
		long mod=1000000007;
		long pow=1;
		long x=a;
		while(b!=0)
		{
			if((b&1)!=0)pow=(pow*x)%mod;
			x=(x*x)%mod;
			b/=2;
		}
		return pow;
	}
	static long toggleBits(long x)//one's complement || Toggle bits
	{
		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;

		return ((1<<n)-1)^x;
	}
	static int countBits(long a)
	{
		return (int)(Math.log(a)/Math.log(2)+1);
	}
	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}
	static boolean isPrime(long N)
	{
		if (N<=1)  return false; 
		if (N<=3)  return true; 
		if (N%2 == 0 || N%3 == 0) return false; 
		for (int i=5; i*i<=N; i=i+6) 
			if (N%i == 0 || N%(i+2) == 0) 
				return false; 
		return true; 
	}
	static long GCD(long a,long b) 
	{
		if(b==0)
		{
			return a;
		}
		else return GCD(b,a%b );
	}

	//Debugging Functions Starts

	static void print(char A[])
	{
		for(char c:A)System.out.print(c+" ");
		System.out.println();
	}
	static void print(boolean A[])
	{
		for(boolean c:A)System.out.print(c+" ");
		System.out.println();
	}
	static void print(int A[])
	{
		for(int a:A)System.out.print(a+" ");
		System.out.println();	
	}
	static void print(long A[])
	{
		for(long i:A)System.out.print(i+ " ");
		System.out.println();

	}
	static void print(ArrayList<Integer> A)
	{
		for(int a:A)System.out.print(a+" ");
		System.out.println();
	}

	//Debugging Functions END
	//----------------------
	//IO FUNCTIONS STARTS
	static HashMap<Integer,Integer> Hash(int A[])
	{
		HashMap<Integer,Integer> mp=new HashMap<>();
		for(int a:A)
		{
			int f=mp.getOrDefault(a,0)+1;
			mp.put(a, f);
		}
		return mp;
	}
	static int i()
	{
		return in.nextInt();
	}

	static long l()
	{
		return in.nextLong();
	}

	static int[] input(int N){
		int A[]=new int[N];
		for(int i=0; i<N; i++)
		{
			A[i]=in.nextInt();
		}
		return A;
	}

	static long[] inputLong(int N)     {
		long A[]=new long[N];
		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
		return A;
	}

	//IO FUNCTIONS END

}
class pair {
	int index,col;
	pair(int col,int index)
	{
		this.col=col;
		this.index=index;
	}
}

//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
class FastReader
{
	BufferedReader br;
	StringTokenizer st;
	public FastReader()
	{
		br=new BufferedReader(new InputStreamReader(System.in));
	}

	String next()
	{
		while(st==null || !st.hasMoreElements())
		{
			try
			{
				st=new StringTokenizer(br.readLine());
			}
			catch(IOException e)
			{
				e.printStackTrace();
			}
		}
		return st.nextToken();
	}

	int nextInt()
	{
		return Integer.parseInt(next());
	}

	long nextLong()
	{
		return Long.parseLong(next());
	}
	//gey
	double nextDouble()
	{
		return Double.parseDouble(next());
	}

	String nextLine()
	{
		String str="";
		try
		{
			str=br.readLine();
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		return str;
	}

}