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.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;
import java.util.StringTokenizer;


public class Solution {
	public static final boolean std = true;
	public static final boolean useFastIn = true;
	public static final String inputFile = "input.txt";
	public static final String outputFile = "output.txt";
	
	public final Scanner in;
	public final RFScanner fin;
	public final PrintWriter out;

	public Solution(Scanner i, PrintWriter o) {
		in = i;
		out = o;
		fin = null;
	}
	public Solution(RFScanner i, PrintWriter o) {
		in = null;
		out = o;
		fin = i;
	}
	
	public static void main(String[] args) throws Exception {
		Solution s;
		PrintWriter out;
		InputStream is;
		Closeable in;
		
		if (std) {
			is = System.in;
			out = new PrintWriter(System.out);
		} else {
			is = new FileInputStream(new File(inputFile));
			out = new PrintWriter(new File(outputFile));
		}
		
		if (useFastIn) {
			in = new RFScanner(is);
			s = new Solution((RFScanner) in, out);
		} else {
			in = new Scanner(is);
			s = new Solution((Scanner) in, out);
		}
		
		s.run();
		in.close();
		out.close();
	}


	public void run() throws Exception {
		int n = fin.nextInt();
		int t = fin.nextInt();
		
		BigInteger ans = BigInteger.TEN.pow(n-1);
		BigInteger divider = new BigInteger(String.valueOf(t));
		while (!ans.mod(divider).equals(BigInteger.ZERO)) {
			ans = ans.add(BigInteger.ONE);
		}
		
		if (ans.toString().length() != n) {
			out.println(-1);
		} else {
			out.println(ans);
		}
	}
	
	
	static class RFScanner implements Closeable {
		private BufferedReader reader;
		private StringTokenizer tokenizer;
		
		public RFScanner(InputStream is) {
			reader = new BufferedReader(new InputStreamReader(is));
			tokenizer = new StringTokenizer("");
		}
		
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}
		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
		public float nextFloat() throws IOException {
			return Float.parseFloat(next());
		}
		
		public String next() throws IOException {
			if (hasNext())
				return tokenizer.nextToken();
			return null;
		}
		public boolean hasNext() throws IOException {
			while (!tokenizer.hasMoreTokens()) {
				String s = reader.readLine();
				if (s == null) {
					return false;
				}
				tokenizer = new StringTokenizer(s);
			}
			return true;
		}
		
		@Override
		public void close() throws IOException {
			reader.close();
		}
	}
}