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.*;

public class cfjava {
  public static void main(String[] args) {
    OutputStream outputStream = System.out;
    FastReader in = new FastReader();
    PrintWriter out = new PrintWriter(outputStream);
    PROBLEM solver = new PROBLEM();
    int t = 1;
    // t = in.nextInt();
    for (int i = 0; i < t; i++) {
      solver.solve(in, out);
    }
    out.close();
  }

  static class PROBLEM {
    public void solve(FastReader in, PrintWriter out) {
      int len = in.nextInt();
      int k = in.nextInt();
      char base[] = new char[k * k];
      char filling = 'a';
      char end = (char) ((int) 'a' + (int) (k - 1));
      int idx = 0, pidx = 1;
      while (filling != end) {
        char ch = filling;
        while (ch <= end) {
          base[idx] = ch;
          ch++;
          idx += 2;
        }
        idx--;
        while (pidx < idx) {
          base[pidx] = filling;
          pidx += 2;
        }
        pidx++;
        filling++;

      }
      base[base.length - 1] = end;
      idx = 0;
      for (int i = 0; i < len; i++) {
        out.print(base[idx]);
        idx = (idx + 1) % base.length;
      }
    }

  }

  static 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());
    }

    double nextDouble() {
      return Double.parseDouble(next());
    }

    char nextChar() {
      return next().charAt(0);
    }

    boolean nextBoolean() {
      return !(nextInt() == 0);
    }
    // boolean nextBoolean(){return Boolean.parseBoolean(next());}

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