Olesya loves numbers consisting of n digits, and Rodion only likes numbers that are divisible by t. Find some number that satisfies both of them.

Your task is: given the n and t print an integer strictly larger than zero consisting of n digits that is divisible by t. If such number doesn't exist, print  - 1.

Input

The single line contains two numbers, n and t (1 ≤ n ≤ 100, 2 ≤ t ≤ 10) — the length of the number and the number it should be divisible by.

Output

Print one such positive number without leading zeroes, — the answer to the problem, or  - 1, if such number doesn't exist. If there are multiple possible answers, you are allowed to print any of them.

Examples

Input

3 2


Output

712
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java .util.*;
public class Contest {
	static long []dp =new long [50];
	public static void main(String [] yahia_mostafa) throws IOException,InterruptedException{
		Scanner sc =new Scanner(System.in);
		PrintWriter pw =new PrintWriter(System.out);
		int n=sc.nextInt(),t=sc.nextInt();
		if (t==10) {
			if (n==1)
				pw.println(-1);
			else {
				for (int i=0;i<n-2;++i)
					pw.print("1");
				pw.println(10);
			}
		}else
			for (int i=0;i<n;++i)
				pw.print(t);
		pw.close();
	}
	static long gcd(long a, long b) 
	{ 
	    if (a == 0) 
	        return b; 
	    return gcd(b % a, a); 
	}
	public static long fib(int num) {
		if (num==1||num==2)
			return dp[num]=1l;
		if (num==0)
			return dp[num]=0;
		if(dp[num]!=-1)
			return dp[num];
		return dp[num]=fib(num-1)+fib(num-2);
	}
	public static int fac(int x) {
		if (x==1||x==0)
			return 1;
		return x*fac(x-1);
	}
	static class Scanner {
		StringTokenizer stringTokenizer;
		BufferedReader bfBufferedReader;
		public Scanner(InputStream system) {
			bfBufferedReader=new BufferedReader(new InputStreamReader( system));
		}
		 public Scanner(String file) throws Exception {
	            bfBufferedReader = new BufferedReader(new FileReader( file));
	        }			 
	        public String next() throws IOException {
	            while (stringTokenizer == null || !stringTokenizer.hasMoreTokens())
	                stringTokenizer = new StringTokenizer( bfBufferedReader.readLine());
	            return stringTokenizer.nextToken();
	        }
	 
	        public String nextLine() throws IOException {
	            return bfBufferedReader.readLine();
	        }
	 
	        public int nextInt() throws IOException {
	            return Integer.parseInt(next());
	        }
	 
	        public double nextDouble() throws IOException {
	            return Double.parseDouble(next());
	        }
	 
	        public char nextChar() throws IOException {
	            return next().charAt(0);
	        }
	 
	        public Long nextLong() throws IOException {
	            return Long.parseLong(next());
	        }
	 
	        public boolean ready() throws IOException {
	            return bfBufferedReader.ready();
	        }
	 
	        public void waitForInput() throws InterruptedException {
	            Thread.sleep(3000);
	        }
	    }
	}