Problem: 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

Solution (in JAVA):

Solution:
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

public class Codeforces implements Runnable {

    private BufferedReader br = null;
    private PrintWriter pw = null;
    private StringTokenizer stk = new StringTokenizer("");

    public static void main(String[] args) {
        new Thread(new Codeforces()).run();
    }

    public void run() {

    /*
     * try { br = new BufferedReader(new FileReader("/home/user/freshdb.sql")); pw = new
     * PrintWriter("/home/user/freshdb_fix.sql"); } catch (FileNotFoundException e) {
     * e.printStackTrace(); }
     */

        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        solver();
        pw.close();

    }

    private void nline() {
        try {
            if (!stk.hasMoreTokens())
                stk = new StringTokenizer(br.readLine());
        } catch (IOException e) {
            throw new RuntimeException("KaVaBUnGO!!!", e);
        }
    }

    private String nstr() {
        while (!stk.hasMoreTokens())
            nline();
        return stk.nextToken();
    }

    private int ni() {
        return Integer.valueOf(nstr());
    }

    private long nl() {
        return Long.valueOf(nstr());
    }

    private double nd() {
        return Double.valueOf(nstr());
    }

    private BigInteger nbi() {
        return new BigInteger(nstr());
    }

    String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
        }
        return null;
    }

    class Point {
        int x;
        int y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    private void bfs(int t, boolean[] using, int[][] g) {
        Stack<Integer> st = new Stack<Integer>();
        int n = using.length;
        st.add(t);
        while (!st.empty()) {
            int p = st.pop();
            for (int i = 0; i < n; i++) {
                if (g[p][i] == 1 && !using[i]) {
                    st.add(i);
                    using[i] = true;
                }
            }
        }
    }

    public int gcd(int a, int b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    private boolean checkPrime(int a) {
        for (int i = 2; i <= Math.sqrt(a); i++) {
            if (a % i == 0)
                return false;
        }
        return true;
    }


    class KeySet implements Comparable<KeySet> {
        int key;
        int value;

        public KeySet(int key, int value) {
            this.key = key;
            this.value = value;
        }

        public int getKey() {
            return key;
        }

        public void setKey(int key) {
            this.key = key;
        }

        @Override
        public int compareTo(KeySet keySet) {
            if (this.value > keySet.value) {
                return 1;
            } else if (this.value < keySet.value) {
                return -1;
            } else {
                return 0;
            }
        }

        public int getValue() {
            return value;
        }

        public void setValue(int value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return "{" + key + "; " + value + "}";
        }
    }

    BigInteger toPositive(BigInteger bi) {
        return bi.signum() < 0 ? bi.negate() : bi;
    }

    int fact(int x) {
        int ans = 1;
        for (int i = 1; i <= x; i++) {
            ans *= i;
        }
        return ans;
    }

    private long getZeroIfNegative(long n) {
        return n > 0 ? n : 0;
    }

    private boolean checkPalindrome(String s) {
        for (int i = 0; i < s.length() / 2 + 1; i++) {
            if (s.charAt(i) != s.charAt(s.length() - i - 1)) {
                return false;
            }
        }
        return true;
    }

    private void solver() {
        int n = ni(), t = ni();
        if (t != 10) {
            for (int i = 0; i < n; i++) {
                System.out.print(t);
            }
        } else {
            if (n == 1) {
                System.out.println(-1);
            } else {
                System.out.print(1);
                for (int i = 1; i < n; i++) {
                    System.out.print(0);
                }
            }
        }
    }

    void exit() {
        pw.close();
        System.exit(0);
    }

}