Little penguin Polo adores strings. But most of all he adores strings of length n.

One day he wanted to find a string that meets the following conditions:

  1. The string consists of n lowercase English letters (that is, the string's length equals n), exactly k of these letters are distinct. 
  2. No two neighbouring letters of a string coincide; that is, if we represent a string as s = s1s2... sn, then the following inequality holds, si ≠ si + 1(1 ≤ i < n). 
  3. Among all strings that meet points 1 and 2, the required string is lexicographically smallest. 



Help him find such string or state that such string doesn't exist.

String x = x1x2... xp is lexicographically less than string y = y1y2... yq, if either p < q and x1 = y1, x2 = y2, ... , xp = yp, or there is such number r (r < p, r < q), that x1 = y1, x2 = y2, ... , xr = yr and xr + 1 < yr + 1. The characters of the strings are compared by their ASCII codes.

Input

A single line contains two positive integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 26) — the string's length and the number of distinct letters.

Output

In a single line print the required string. If there isn't such string, print "-1" (without the quotes).

Examples

Input

7 4


Output

ababacd


Input

4 7


Output

-1
import java.io.*;
import java.util.*;
import java.math.*;

public class Main implements Runnable{
    boolean withFiles = false;


    private void solve() throws IOException{
        int n = in.nextInt();
        int k = in.nextInt();

        if (k == 1 && n != 1 || k > n) {
            out.println(-1);
            return;
        }

        StringBuilder s = new StringBuilder();
        s.setLength(n);
        if (k == 1) {
            for (int i = 0; i < n; i++)
                s.setCharAt(i, 'a');
        }
        else {
            for (int i = 0; i < n - (k - 2); i++)
                s.setCharAt(i, (i % 2 == 0) ? 'a' : 'b');
            for (int i = 0; i < k - 2; i++)
                s.setCharAt((n - (k - 2)) + i, (char)((int)'c' + i));
        }

        out.println(s.toString());
    }

    private static class FastScanner{
        private BufferedReader reader;
        private StringTokenizer tokenizer;
        String cache;
        int cur;

        FastScanner(Reader r) throws IOException{
            reader = new BufferedReader(r);
            tokenizer = new StringTokenizer("");
	    cache = null;
	    cur = 0;
        }

        public boolean hasNext(){
            if (cache != null && cur < cache.length())
                return true;
            try {
                while (!tokenizer.hasMoreTokens()){
                    String line = reader.readLine();
                    if (line == null)
                        return false;
                    tokenizer = new StringTokenizer(line);
                }
                cache = tokenizer.nextToken();
		cur = 0;
            }
            catch(IOException e) {
                return false;
            }
            return true;
        }
        
        public char nextChar() throws IOException{
            if (!hasNext())
		throw new EOFException();
	    return cache.charAt(cur++);
        }

        public String next() throws IOException{
            if (!hasNext())
                throw new EOFException();
            String result = (cur == 0) ? cache : cache.substring(cur);
            cache = null;
            return result;
        }

        public int nextInt() throws IOException{
            return Integer.parseInt(this.next());
        }

        public long nextLong() throws IOException{
            return Long.parseLong(this.next());
        }

        public double nextDouble() throws IOException{
            return Double.parseDouble(this.next());
        }

        public BigInteger nextBigInteger() throws IOException{
            return new BigInteger(this.next());
        }

        public void close() throws IOException{
            reader.close();
            tokenizer = new StringTokenizer("");
        }
    }


    public static void main(String args[]) throws IOException{
        new Thread(null, new Main(), "Thread #228", 64 * 1024 * 1024).start();
    }

    public void run(){
        try{
	    if (withFiles) {
		in = new FastScanner(new FileReader("input.txt"));
		out = new PrintWriter(new FileWriter("output.txt"));
	    }
	    else {
		in = new FastScanner(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
	    }
            solve();
            in.close();
            out.close();
        }
        catch(IOException e){
            e.printStackTrace();
        }
    }

    FastScanner in;
    PrintWriter out;
}
