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

Solution:
/*input
9 3

*/
//In name of THE GOD
#include<iostream>
#include <algorithm>  
#include <string.h>              
#include<bits/stdc++.h>
#define ll long long int
#define lld long double
#define boost ios_base::sync_with_stdio(false); cin.tie(NULL);
#define tinput ll T; cin>>T; while(T--)
#define fo(i,a,b) for(ll i=a;  i<b; i++)
#define ro(i,a,b) for(ll i=a; i>=b; i--)
#define all(x) x.begin(),x.end()
#define pi  3.14159265358979323846
#define nl cout<<"\n"
ll min(ll x, ll y) {
  return (x<y)?x:y;
}
ll max(ll x, ll y) {
  return (x>y)?x:y;
}

// Pair
#define pii                  pair<int, int>
#define pllll                pair<long long int, long long int>
#define F                    first
#define S                    second


// Vector
#define vll                  vector<long long int>
#define vi                   vector<int>
#define vpii                 vector< pair<int, int> >
#define vpllll               vector<pair<long long int, long long int> >
#define pb                   push_back
#define popb                 pop_back



// Search
#define lb                   lower_bound
#define ub                   upper_bound
#define mine                 *min_element
#define maxe                 *max_element
#define bsearch              binary_search

ll fastexpo(ll base,ll power)
{
  ll res=1;
  while(power)
  {
    if(power%2 == 0)
    {
     base*= base;
     power/=2;
    }
    else
    {
     res *= base;
     power--;
    }
  }
  return res;
}

ll modexpo(ll base,ll power,ll mod)
{
  ll res=1;
  while(power)
  {
    if(power%2 == 0)
    {
     base = (base*base)%mod;
     power/=2;
    }
    else
    {
     res = (base*res)%mod;
     power--;
    }
  }
  return res;
}

// SEIVE 
const ll SN = 1e6;

bool prime[SN + 1];
void Sieve(int n)
{ 
    memset(prime, true, sizeof(prime));
 
    for (int p = 2; p * p <= n; p++)
    {
        if (prime[p] == true) 
        {
            for (int i = p * p; i <= n; i += p)
                prime[i] = false;
        }
    }
}


// atoi string convert into int
// stol string convert into long 
// stoll string convert into long long int
// memset(dp, -1, sizeof(dp));
// cout<<fixed<<setprecision(10)<<ans; for 10 decimal value
// global array size should be an const (int or long long int).


// log2(n) = no of bit in that number n;
// gcd(0,x) = x;
// lcm(x,y) = x*y / __gcd(x,y);
/* |x1-x2|+|y1-y2| = max(a,b,c,d);
   a = (x1+y1) - (x2+y2);
   b = (x1-y1) - (x2-y2);
   c = (-x1+y1) - (-x2+y2);
   d = (-x1-y1) - (-x2-y2);
*/

/* vector<int>v(n) 
   The compiler would there only create an dynamic array of size N 
   with all values initialized to zero.

   vector<int> v[N];
   It creates a static array of N vectors(size of array is N and 
   vector is dynamic).
*/

//struct trainers;
//priority_queue<trainers, vector<trainers>, function<bool(trainers,trainers)>>p(comp);
//in priority_queue priority depend on greater the no.
/*
struct comp
{
   bool operator()(trainers& a,trainers& b)
   {
      return a.rs < b.rs; // for inc order;
   }
};

*/

//   MEDIAN ELEMENT (from priority_queue) for inc seq;
/*
 priority_queue <int> maxHeap;
    priority_queue < int, vector <int>, greater <int> > minHeap;

     if (maxHeap.size() == 0 && minHeap.size() == 0)
          maxHeap.push (n);
        else {
         int  nb1 = maxHeap.top ();
          if (n >= nb1)
            minHeap.push (n);
          else
            maxHeap.push (n);

          if (maxHeap.size() < minHeap.size()) {
           int temp = minHeap.top ();
            minHeap.pop ();
            maxHeap.push (temp);
          }
          else if (maxHeap.size() > minHeap.size() + 1) {
            int temp = maxHeap.top ();
            maxHeap.pop ();
            minHeap.push (temp);
          }
        }
*/
/* int binary(int n)
{
  int b ;           // if n is not power of 2 b = log2(n);
                   // if n is power of 2  b=log2(n)+1;
  for(int i=b-1;i>=0;i--) 
  {
    cout<<(n & (1 << i))<<" ";
  }
}
*/

/* 
   TO FIND nCr.

   ll mod=1e9+7;
ll f[n+1];
ll power(ll x,ll y)
{
  if(y==0)
  return 1;
  ll ret=power(x,y/2);
  ret*=ret;
  ret%=mod;
  if(y%2==1)
  {
    ret*=x;
    ret%=mod;
  }
  return ret;
}
ll C(ll n,ll r)
{
  if(n==r)
  return 1;
  if(n<r)
  return 0;
  ll ret=f[n];
  ll y=f[r]*f[n-r];
  y%=mod;
  y=power(y,mod-2);
  ret*=y;
  ret%=mod;
  return ret;
}


int main()
{

    f[0]=1;
  for(int i=1;i<=n;i++)
  {
    f[i]=f[i-1]*i;
    f[i]%=mod;
  }
}

*/
/*
      FIND & UNION METHOD OF DSU

 int find(int n)
{
  if(par[n] == n) return n;
  else return par[n] = find(par[n]);
}

void unions(int a,int b)
{
  a = find(a);
  b = find(b);

  if(par[a] == par[b]) return;
  else 
    {
    if(r[a] > r[b])
    {
      // a would be parent;
      par[b] = a;
      r[a] += r[b];
    }
    else
    {
      // b would be parent;
      par[a] = b;
      r[b] += r[a];
    }
  }
}

int main()
{
  fo(i,1,n+1) par[i] = i, r[i] = 1;
}

*/
/*
     TO CONTAIN SEGMENTS OF STRING OF SAME CHAR.
int pt=0;
  fo(i,1,n)
  {
    if(s[i] != s[pt])
    {
      v.pb(i-pt);
      pt = i;
    }
  }
  v.pb(n-pt);
*/

/*
     DFS

     N = number of vertex.

vector<int>adj[N];
bool visited[N];
bool dfs(int cur,int des)
{
  if(cur == des) 
    return true;

  visited[cur]=true;
  bool found = false;

  for(int adj_vertex:adj[cur])
  {
    if(visited[adj_vertex])
      continue;

    if(dfs(adj_vertex,des))
      found = true;
  }
  return found;
}

*/
/*
   BFS

   N = number of vertex.

vector<int>adj[N];
bool visited[N];
int dis[N];

void bfs(int s)
{
  queue<int>q;

  for(int i=0;i<N;i++)
    dis[i] = INF;

  q.push(s);
  visited[s]=true;
  dis[s]=0;

  while(!q.empty())
  {
    int cur = q.front();
    q.pop();
    for(int adj_vertex:adj[cur])
    {
      if(visited[adj_vertex])
        continue;
      q.push(adj_vertex);
      visited[adj_vertex];
      dis[adj_vertex] = dis[cur]+1;
    }
  }
}

*/




using namespace std;


void solve()
{
  int n,k; cin>>n>>k;
  string res ="a";
  int c= 0;
  int adj[50*50+50];

   memset(adj, 0, sizeof(adj));

  fo(i,0,n)
  {
    fo(j,c,k)
    {
      int x = (res.back()-'a')*26 + j;

      if(adj[x]) continue;

     
        res += (j+'a');
        adj[x]++;

        if(j == k-1) c++;
        break;
    }
  
  }

  string s;

  while(res.size()+s.size() <= n) s+=res;

  int i=0;

  while(s.size() < n) s += res[i++];

  cout<<s;
  nl;
}

 
int main()
{
    boost;
 // READ THE QUESTION PROPERLY 
 // BECOME A YELLOW CODER
 
  // tinput
  solve();

  return 0;
}