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.math.BigInteger;
import java.util.*;
	
	
	public class Practice {
		private static InputStream stream;
		private static byte[] buf = new byte[1024];
		private static int curChar;
		private static int numChars;
		private static SpaceCharFilter filter;
		private static PrintWriter pw;
		private static long mod=1000000009;
	
	    public static void main(String[] args) {
	    	InputReader(System.in);
			pw = new PrintWriter(System.out); 
	        new Thread(null ,new Runnable(){
	           public void run(){
	               try{
	                   solve();//This is solution method
               pw.close();
           } catch(Exception e){
               e.printStackTrace();
           }
       }
   },"1",1<<26).start();
	    				   }
	    				    static long sort(int a[])
	        		    	{  int n=a.length;
	        		    		int b[]=new int[n];	
	        		    		return mergeSort(a,b,0,n-1);}
	        		    	static long mergeSort(int a[],int b[],long left,long right)
	        		    	{ long c=0;if(left<right)
	        		    	 {   long mid=left+(right-left)/2;
	        		    		 c= mergeSort(a,b,left,mid);
	        		    		 c+=mergeSort(a,b,mid+1,right);
	        		    		 c+=merge(a,b,left,mid+1,right); }	
	        		    		return c;	 }
	        		    	static long merge(int a[],int  b[],long left,long mid,long right)
	        		    	{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
	        		    	while(i<=(int)mid-1&&j<=(int)right)
	        		    	{ if(a[i]>a[j]) {b[k++]=a[i++]; }
	        		    	else	{ b[k++]=a[j++];c+=mid-i;}}
	        		    	while (i <= (int)mid - 1)   b[k++] = a[i++]; 
	        		    	while (j <= (int)right) b[k++] = a[j++];
	        		    	for (i=(int)left; i <= (int)right; i++) 
	        		    		a[i] = b[i];  return c;  }
	        		    		    
	    				    
	    				    
	        		    	public static void solve() {
 

	        		    		int n=nextInt();
	        		    		int k=nextInt();
	        		    		if(n==1 && k==1){
	        		    			pw.println("a");
	        		    			return;
	        		    		}
	        		    		if(k>n || k==1){
	        		    			pw.println(-1);
	        		    			return;
	        		    		}
	        		    		LinkedList<Character> l=new LinkedList<Character>();
	        		    		for(char c='a';c<='z';c++){
	        		    			l.add(c);
	        		    		}
	        		    		int dist=k-2;
	        		    		StringBuilder sb=new StringBuilder();
	        		    		for(int i=0;i<n-dist;i++){
	        		    			if(i%2==0){
	        		    				sb.append("a");
	        		    			}else{
	        		    				sb.append("b");
	        		    			}
	        		    		}
	        		    		for(int i=2;i<l.size();i++){
	        		    			if(dist==0){
	        		    				break;
	        		    			}
	        		    			sb.append(l.get(i));
	        		    			dist--;
	        		    		}
	        		    		pw.println(sb);
	        		    	}
	        		    		
	        		    		
	        		    				
	        		        
	public static boolean isVowel(char c){        		    		
		if(c=='a' || c=='i'|| c=='e' || c=='o' || c=='u')
			return true;
		return false;
	}
	
	public static long trailingZeroes(long n) {
	    long count = 0;

	    while (n > 0) {
	        n /= 5;
	        count += n;
	    }

	    return count;
	}

    public static int largestPrimeFactor(long number) {
        int i;

        for (i = 2; i <= number; i++) {
            if (number % i == 0) {
                number /= i;
                i--;
            }
        }

        return i;
}
   
	public static long pow(long n, long p) {
		if(p==0)
			return 1;
		if(p==1)
			return n;
		if(p%2==0){
			long temp=pow(n, p/2);
		return (temp*temp);
		}else{
			 	long temp=pow(n,p/2);
			 	temp=(temp*temp);
			 	return(temp*n);
			 	
		}
	}
    public static String reverseString(String s) {
		StringBuilder sb = new StringBuilder(s);
		sb.reverse();
		return (sb.toString());
	}
    private static BigInteger ncr(int n,int k){
    	if (k < 0 || k > n) return BigInteger.ZERO;
        if (n-k < k) k = n-k;

        BigInteger x = BigInteger.ONE;
        for (int i = 1; i <= k; i++) {
            x = x.multiply(new BigInteger(""+(n-i+1)));
x = x.divide(new BigInteger(""+i));
        }

return x;
    }
    static long fact[];
private static void factmod(int n,int mod){
	fact=new long[n+1];
	fact[0]=1;
	for(int i=1;i<=n;i++){
		fact[i]=i*fact[i-1];
		//fact[i]%=mod;

	}
	
}
private static long phi(long n){
	long ans=n;
	if(n%2==0)
		ans-=(ans/2);
	while(n%2==0)
	{
		n/=2;
		
	}
	for(int i=3;i*i<=n;i+=2){
		if(n%i==0){
		while(n%i==0){
			n/=i;
		}
		ans-=(ans/i);
		}
	}
	if(n>2)
		ans-=(ans/n);
	
	return ans;
}
static long d,x,y;
static long modInverse(long A, long M)
{
extendedEuclid(A,M);
return (x%M+M)%M;    //x may be negative
}
static void extendedEuclid(long A, long B) {
if(B == 0) {
d = A;
x = 1;
y = 0;
}
else {
extendedEuclid(B, A%B);
long temp = x;
x = y;
y = temp - (A/B)*y;
}
}
static boolean prime[];
static int spf[];
public static void sieve(int n){
	prime=new boolean[n+1];
	spf=new int[n+1];
	
	Arrays.fill(spf, 1);
	Arrays.fill(prime, true);
prime[1]=false;
	spf[2]=2;
	for(int i=4;i<=n;i+=2)
	{
		spf[i]=2;
		prime[i]=false;
	}

for(int i=3;i<=n;i+=2){
	if(prime[i]){
		spf[i]=i;
		for(int j=2*i;j<=n;j+=i){
			
			prime[j]=false;
		if(spf[j]==1){
			spf[j]=i;
		}
		}
	}
}
	
}
public static boolean isPrime(long n) {
	
	if (n <= 1)
		return false;
	if (n <= 3)
		return true;

	if (n % 2 == 0 || n % 3 == 0)
		return false;

	for (long i = 5; i * i <= n; i = i + 6)
		if (n % i == 0 || n % (i + 2) == 0)
			return false;

	return true;
}

    public static long pow(long n, long p,long mod) {
		if(p==0)
			return 1;
		if(p==1)
			return n%mod;
		if(p%2==0){
			long temp=pow(n, p/2,mod);
		return (temp*temp)%mod;
		}else{
			 	long temp=pow(n,p/2,mod);
			 	temp=(temp*temp)%mod;
			 	return(temp*n)%mod;
			 	
		}
	}
	public static long gcd(long x, long y) {
		if (x == 0)
			return y;
		else
			return gcd( y % x,x);
	}
	
	
	public static void InputReader(InputStream stream1) {
		stream = stream1;
	}
 
	private static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
 
	private static boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}
 
	private static int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}
 
	private static int nextInt() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
	sgn = -1;
	c = read();
}
int res = 0;
do {
	if (c < '0' || c > '9')
	throw new InputMismatchException();
res *= 10;
res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
 
	private static long nextLong() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		int sgn = 1;
		if (c == '-') {
	sgn = -1;
	c = read();
}
long res = 0;
do {
	if (c < '0' || c > '9')
	throw new InputMismatchException();
res *= 10;
res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}
 
	private static String nextToken() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}
 
	private static String nextLine() {
		int c = read();
		while (isSpaceChar(c))
			c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isEndOfLine(c));
		return res.toString();
	}
 
	private static int[] nextIntArray(int n) {
		int[] arr = new int[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextInt();
		}
		return arr;
	}
 
	private static int[][] next2dArray(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;
	}
	private static char[][] nextCharArray(int n,int m){
		char [][]c=new char[n][m];
		for(int i=0;i<n;i++){
			String s=nextLine();
			for(int j=0;j<s.length();j++){
				c[i][j]=s.charAt(j);
			}
		}
		return c;
	}
 
	private static long[] nextLongArray(int n) {
		long[] arr = new long[n];
		for (int i = 0; i < n; i++) {
			arr[i] = nextLong();
		}
		return arr;
	}
 
	private static void pArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			pw.print(arr[i] + " ");
		}
		pw.println();
		return;
	}
 
	private static void pArray(long[] arr) {
		for (int i = 0; i < arr.length; i++) {
			pw.print(arr[i] + " ");
		}
		pw.println();
		return;
	}
 
	private static void pArray(boolean[] arr) {
		for (int i = 0; i < arr.length; i++) {
			pw.print(arr[i] + " ");
		}
		pw.println();
		return;
	}
 
	private static boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}
 
	private interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

	
}	

/*class Pair implements Comparable<Pair>{

	
	int  from,to,a,b;
	Pair(int from,int to,int a,int b){
	
		this.from=from;
		this.to=to;
		this.a=a;
		this.b=b;
	}
	@Override
	public int compareTo(Pair o) {

		return 0;
		//return (int)(o.size-size);
	}
	public int hashCode() {
			//int hu = (int) (x ^ (x >>> 32));
			//int hv = (int) (y ^ (y >>> 32));
			//int hw = (int) (mass ^ (mass >>> 32));
			//return 31 * hu + hv ;
		return 0;
		}
		public boolean equals(Object o) {
			Pair other = (Pair) o;
		//	return x == other.x && y == other.y;
		return false;
		}
}*/

