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.awt.List;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.util.StringTokenizer;

import java.util.Collections;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Random;

public class Main {

    class Input {
        BufferedReader bf;
        StringTokenizer st;

        Input(InputStream stream) throws IOException {
            bf = new BufferedReader(new InputStreamReader(stream));
            st = new StringTokenizer("");
        }

        int nextInt() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            
            return Integer.parseInt(st.nextToken());
        }

        long nextLong() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Long.parseLong(st.nextToken());
        }

        double nextDouble() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return Double.parseDouble(st.nextToken());
        }

        void readLine() throws IOException {
            st = new StringTokenizer(bf.readLine());
        }

        String nextString() throws IOException {
            if (!st.hasMoreTokens())
                st = new StringTokenizer(bf.readLine());
            return st.nextToken();
        }

        String nextLine() throws IOException {
            return bf.readLine();
        }

        void close() throws IOException {
            bf.close();
        }
    }

    Input in;

    public class Problem {

        /*
        class Point implements Comparable<Point> {
            int x, y, p;

            Point(int a, int b, int k) {
                x = a;
                y = b;
                p = k;
            }

            @Override
            public int compareTo(Point o) {
                // TODO Auto-generated method stub
                return Integer.compare(this.x, o.x);
            }
        }*/
        void f(int n)
        {
            char[] c = new char[] { 'a', 'b' };
            int i = 0;
            while(n > 0)
            {
                System.out.print(c[i]);
                i = (i + 1) % 2;
                n--;
            }
        }
        @SuppressWarnings("deprecation")
        public void solve() throws IOException {
            
            int n = in.nextInt();
            int k = in.nextInt();
            if(n < k || (k == 1 && n > 1))
            {
                System.out.print(-1);
                return;
            }
            if(n == 1)
            {
                System.out.println('a');
                return;
            }

            char[] c = new char[] { 'a', 'b' };
            int i = 0;
            k -= 2;
            while(n > k)
            {
                System.out.print(c[i]);
                i = (i + 1) % 2;
                n--;
            }
            char j = 'c';
            for(i = 0; i < n; i++, j++)
                System.out.print(j);
            /*
            int n = in.nextInt(), m = in.nextInt();
            int d = in.nextInt();
            
            int[][] a = new int[n][m];
            int s = 0;
            int min = Integer.MAX_VALUE;
            int max = Integer.MIN_VALUE;
            
            
            for(int i = 0; i < n; i++)
                for(int j = 0; j < m; j++)
                {
                    a[i][j] = in.nextInt();
                    if(a[i][j] % d != 0)
                    {
                        System.out.println(-1);
                        return;
                    }
                    if(min > a[i][j])
                        min = a[i][j];
                    if(max < a[i][j])
                        max = a[i][j];
                    s += a[i][j];
                }
            int res = Integer.MAX_VALUE;
            int e;
            //s /= d;
            n *= m;
            for(int i = min; i <= max; i += d)
            {
                e = Math.abs(n * i - s) / d;
                System.out.println(e);
                if(e < res)
                    res = e;
            }
            //System.out.println(d);
            //System.out.println(res);
*/
        }
    }


    public void solveProblem() throws IOException {
        
        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        in = new Input(oj ? System.in : new FileInputStream("D:/Codes/Java/input.txt") );
        
        // in = new Input(System.in);
        // in = new Input(new FileInputStream("D:/Codes/Java/input.txt"));
        new Problem().solve();
        in.close();
    }

    public static void main(String[] args) throws IOException {

        new Main().solveProblem();
    }

}
