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.*;
import java.util.*;

/**
 * Made by egor https://github.com/chermehdi/egor.
 *
 * @author Azuz 
 *
 */
public class Main {


  void solve(InputReader in, PrintWriter out) {
    int n = in.nextInt();
    int k = in.nextInt();

    ArrayDeque<Integer>[] q = new ArrayDeque[k];
    for (int i = 0; i < k; ++i) {
      q[i] = new ArrayDeque<>();
      for (int j = 0; j < k; ++j) {
        q[i].offer(j);
      }
      if (i == k - 1) {
        int x = q[i].poll();
        q[i].offer(x);
      }
    }

    int current = 0;
    out.print('a');
    for (int i = 1; i < n; ++i) {
      int next = q[current].pollFirst();
      q[current].addLast(next);
      out.print(c(next));
      current = next;
    }

    out.println();
  }

  public char c(int ord) {
    return (char) ('a' + ord);
  }

  public static void main(String[] args) {
    InputReader in = new InputReader(System.in);
    try (PrintWriter out = new PrintWriter(System.out)) {
      new Main().solve(in, out);
    }
  }
}

class Pair implements Comparable<Pair> {
  int f, s;
  public Pair(int f, int s) {
    this.f = f;
    this.s = s;
  }

  @Override
  public int compareTo(Pair p) {
    return this.s - p.s;
  }
}

class InputReader  {

  private InputStream stream;
  private static final int DEFAULT_BUFFER_SIZE = 1 << 16;
  private static final int EOF = -1;
  private byte[] buf = new byte[DEFAULT_BUFFER_SIZE];
  private int curChar;
  private int numChars;

  public InputReader(InputStream stream) {
    this.stream = stream;
  }

  public int[] readIntArray(int tokens) {
    int[] ret = new int[tokens];
    for (int i = 0; i < tokens; i++) {
      ret[i] = nextInt();
    }
    return ret;
  }

  public int read() {
    if (this.numChars == EOF) {
      throw new UnknownError();
    } else {
      if (this.curChar >= this.numChars) {
        this.curChar = 0;

        try {
          this.numChars = this.stream.read(this.buf);
        } catch (IOException ex) {
          throw new InputMismatchException();
        }

        if (this.numChars <= 0) {
          return EOF;
        }
      }

      return this.buf[this.curChar++];
    }
  }

  public int nextInt() {
    int c;
    for (c = this.read(); isSpaceChar(c); c = this.read()) {
    }

    byte sgn = 1;
    if (c == 45) {
      sgn = -1;
      c = this.read();
    }

    int res = 0;

    while (c >= 48 && c <= 57) {
      res *= 10;
      res += c - 48;
      c = this.read();
      if (isSpaceChar(c)) {
        return res * sgn;
      }
    }

    throw new InputMismatchException();
  }

  public long nextLong() {
    int c;
    for (c = this.read(); isSpaceChar(c); c = this.read()) {
    }

    byte sgn = 1;
    if (c == 45) {
      sgn = -1;
      c = this.read();
    }

    long res = 0;

    while (c >= 48 && c <= 57) {
      res *= 10L;
      res += c - 48;
      c = this.read();
      if (isSpaceChar(c)) {
        return res * sgn;
      }
    }
    throw new InputMismatchException();
  }

  public double nextDouble() {
    double ret = 0, div = 1;
    int c = read();
    while (c <= ' ') {
      c = read();
    }
    boolean neg = (c == '-');
    if (neg) {
      c = read();
    }

    do {
      ret = ret * 10 + c - '0';
    }
    while ((c = read()) >= '0' && c <= '9');

    if (c == '.') {
      while ((c = read()) >= '0' && c <= '9') {
        ret += (c - '0') / (div *= 10);
      }
    }

    if (neg) {
      return -ret;
    }
    return ret;
  }

  public String next() {
    int c;
    while (isSpaceChar(c = this.read())) {
    }

    StringBuilder result = new StringBuilder();
    result.appendCodePoint(c);

    while (!isSpaceChar(c = this.read())) {
      result.appendCodePoint(c);
    }

    return result.toString();
  }

  public String nextLine() {
    int c;
    StringBuilder result = new StringBuilder();
    boolean read = false;
    while ((c = this.read()) != '\n') {
      if (c == -1) {
        return null;
      }
      result.appendCodePoint(c);
      read = true;
    }
    if (!read) {
      return null;
    }
    return result.toString();
  }

  public static boolean isSpaceChar(int c) {
    return c == 32 || c == 10 || c == 13 || c == 9 || c == EOF;
  }

  public int[] nextIntArray(int n) {
    int[] arr = new int[n];
    for (int i = 0; i < n; i++) {
      arr[i] = nextInt();
    }
    return arr;
  }

  public long[] nextLongArray(int n) {
    long[] arr = new long[n];
    for (int i = 0; i < n; i++) {
      arr[i] = nextLong();
    }
    return arr;
  }

  public int[][] nextIntMatrix(int n, int m) {
    int[][] arr = new int[n][m];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        arr[i][j] = nextInt();
      }
    }
    return arr;
  }

  public long[][] nextLongMatrix(int n, int m) {
    long[][] arr = new long[n][m];
    for (int i = 0; i < n; i++) {
      for (int j = 0; j < m; j++) {
        arr[i][j] = nextLong();
      }
    }
    return arr;
  }

  public char[] nextCharArray() {
    return next().toCharArray();
  }

  public double[] nextDoubleArray(int n) {
    double[] ret = new double[n];
    for (int i = 0; i < n; i++) {
      ret[i] = nextDouble();
    }
    return ret;
  }

  public int[]
  nextIntArrayOneBased(int n) {
    int[] ret = new int[n + 1];
    for (int i = 1; i <= n; i++) {
      ret[i] = nextInt();
    }
    return ret;
  }

  public char[][] nextCharMatrix(int n, int m) {
    char[][] res = new char[n][m];
    for (int i = 0; i < n; ++i) {
      res[i] = nextCharArray();
    }
    return res;
  }
}
