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.*;
import java.math.BigInteger;
import java.util.*;

public class A {

    public static void main(String[] args) throws Exception {
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

        int L = in.nextInt();
        int M = in.nextInt();

        BigInteger start = BigInteger.TEN.pow(L - 1);
        BigInteger mod = start.mod(BigInteger.valueOf(M));
        if (mod.equals(BigInteger.ZERO))
            out.print(start.toString());
        else {
            BigInteger result = start.add(BigInteger.valueOf(M - mod.intValue()));
            if (result.toString().length() == L)
                out.print(result.toString());
            else
                out.write("-1");
        }
        out.write('\n');
        out.close();
    }

    public static long raise(final long power) {
        long M = 2;
        long R = 1;
        for (long p = power; p > 0; p >>= 1) {
            if ((p & 1) == 1) R = (R * M);
            M = (M * M);
        }
        return R;
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[2048];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public InputReader() {
        this.stream = System.in;
    }

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public InputReader(SpaceCharFilter filter) {
        this.stream = System.in;
        this.filter = filter;
    }

    public InputReader(InputStream stream, SpaceCharFilter filter) {
        this.stream = stream;
        this.filter = filter;
    }

    public int read() {
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public char nextChar() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        return (char) c;
    }

    public int nextDigit() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        return c - '0';
    }

    public int nextInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        boolean negative = false;
        if (c == '-') {
            negative = true;
            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 negative ? -res : res;
    }

    public int nextUnsignedInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res;
    }

    public final long nextLong() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        boolean negative = false;
        if (c == '-') {
            negative = true;
            c = read();
        }
        long res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return negative ? -res : res;
    }

    public final long nextUnsignedLong() {
        int c = read();
        while (isSpaceChar(c)) {
            c = read();
        }
        long res = 0;
        do {
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res;
    }

    public double nextDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        long 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 (!(c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1 || c == '.'));

        if (c != '.') {
            return res * sgn;
        }
        c = read();

        long aft = 0;
        int len = 1;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            aft *= 10;
            len *= 10;
            aft += c - '0';
            c = read();
        } while (!isSpaceChar(c));

        return res * sgn + aft / (1.0 * len);
    }

    public String nextLine() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public boolean isEndChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public char[] nextChars() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));

        char[] chars = new char[res.length()];
        res.getChars(0, chars.length, chars, 0);
        return chars;
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}