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.IOException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class P584A {

	private void run() {
		int n = nextInt();
		int t = nextInt();

		
		if (n == 1) {
			if (t < 10) {
				System.out.println(t);
			} else {
				System.out.println(-1);
			}
		} else {
			StringBuilder builder = new StringBuilder();
			builder.append('1');
			for (int i = 0; i < (n - 1); i++) {
				builder.append('0');
			}
			
			BigDecimal init = new BigDecimal(builder.toString());
			BigDecimal divisor = new BigDecimal(t);
			while (true) {
				if (init.remainder(divisor).equals(BigDecimal.ZERO)) {
					System.out.println(init.toPlainString());
					break;
				}
				
				init = init.add(BigDecimal.ONE);
			}
		}
	}


	public boolean isTriangle(int a, int b, int c) {
		return
				(a + b > c)
				&& (a + c > b)
				&& (b + c > a);
	}

	private char nextChar() {
		try {
			return (char) System.in.read();
		} catch (IOException e) {
			throw new RuntimeException(e);
		}
	}

	private char[] incrementWord(char[] input, char maxLetter) {
		int currentIndex = input.length - 1;
		
		while (currentIndex >= 0 && input[currentIndex] == maxLetter) {
			currentIndex--;
		}
		
		if (currentIndex < 0) {
			return input;
		}
		
		input[currentIndex] = (char) (input[currentIndex] + 1);

		for (int i = currentIndex + 1; i < input.length; i++) {
			input[i] = 'a';
		}

		return input;
	}


	private int getFree(Integer currentFree, Map<Integer, Integer> count) {
		while (count.containsKey(currentFree)) {
			currentFree = currentFree + 1;
		}
		return currentFree;
	}


	private double computeArea(double side1, double side2, double side3) {
		double p = (side1 + side2 + side3) / 2d;
		
		return Math.sqrt(p * (p - side1) * (p - side2) * (p - side3));
	}

	private int greaterThan(List<Integer> indexesP2, Integer j) {
		for (int i = 0; i < indexesP2.size(); i++) {
			Integer number = indexesP2.get(i);
			
			if (number > j) {
				return indexesP2.size() - i;
			}
		}
		return 0;
	}

	public static void main(String[] args) {
		P584A notes = new P584A();
		notes.run();
		notes.close();
	}

	private Scanner sc;
	
	private P584A() {
		this.sc = new Scanner(System.in);
	}
	
	private int[] asInteger(String[] values) {
		int[] ret = new int[values.length];
		
		for (int i = 0; i < values.length; i++) {
			String val = values[i];
			ret[i] = Integer.valueOf(val).intValue();
		}
		
		return ret;
	}
	
	private String nextLine() {
		return sc.nextLine();
	}
	
	private long nextLong() {
		return sc.nextLong();
	}
	
	private int nextInt() {
		return sc.nextInt();
	}

	private String readLine() {
		if (sc.hasNextLine()) {
			return (sc.nextLine());
		} else {
			return null;
		}
	}
	
	private void close() {
		try {
			sc.close();
		} catch (Exception e) {
			//log
		}
	}
}
