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.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Main {

    static long m = 1000000007;

    public static void main(String[] args) throws FileNotFoundException {
        FastReader scanner = new FastReader();
//        int t = scanner.nextInt();
        int temp;
//        while (t-- > 0) {
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        StringBuilder res = new StringBuilder();
        if (k == 1) {
            for (int i = 0; i < n; i++) {
                res.append('a');
            }
        } else {
            StringBuilder sb = new StringBuilder();
//            sb.append('a');
            for (int i = 0; i < k; i++) {
//                sb.append((char) (i + 'a')).append((char) (i + 'a'));
                char a = ((char) (i + 'a'));
                sb.append(a);
                for (int j = i + 1; j < k; j++) {
                    char b = ((char) (j + 'a'));
                    sb.append(a).append(b);
//                    String t = a + "" + b;
//                    if (sb.indexOf(t) == -1)
//                        sb.append(b);
//                    t = b + "" + a;
//                    if (sb.indexOf(t) == -1)
//                        sb.append(b);
                }
            }
//            sb.append('a');
//            System.out.println(sb);
            for (int i = 0, j = 0; i < n + 1; i += k, j++) {
                res.append(j % 2 == 0 ? sb : sb);
            }
        }

        // abacadbcbdcda
        // abacadbcbdcdaadcdbcbdacabaadcd
        System.out.println(res.subSequence(0, n));
//        }
    }

    static long fact(long l) {
        long rest = 1;
        for (long i = 2; i < l; i++) {
            rest = ((i % m) * (rest % m)) % m;
        }
        return rest;
    }

    static class Pair {
        int key;
        int value;

        public Pair(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

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

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

    static long gcd(long a, long b) {
        if (a == 0)
            return b;
        return gcd(b % a, a);
    }

    static long lcm(long a, long b) {
        return (a / gcd(a, b)) * b;
    }
}
//6
//100100
//001010
//000000
//110000
//111000
//010100
//8
//01100101
//01000001
//00011000
//00000010
//11000011
//10100010
//10000001
//01100000