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
from sys import stdin, stdout

DEBUG = True

class Scan():
    def __init__(self):
        self.read = stdin.read
        self.input = stdin.readline

    def integer(self, count=1):
        if count == 1:
            return self._integer()
        return [self._integer() for _ in range(count)]

    def _integer(self):
        sym: str = self.read(1)
        while sym != '-' and not sym.isdigit():
            sym = self.read(1)
  
        number, sign = (0, -1) if sym == '-' else (int(sym), 1)
        sym: str = self.read(1)
        while sym.isdigit():
            number = number * 10 + int(sym)
            sym = self.read(1)
        
        return number * sign
    
    def array(self, func=int, sep=' '):
        if func == str:
            return input().split(sep)
        return list(map(func, input().split(sep)))

    def string(self, count=1):
        if count == 1:
            return self._string()
        return [self._string() for _ in range(count)]

    def _string(self):
        sym = self.read(1)
        while sym in ('\n', '\r', ' '):
            sym = self.read(1)
        
        s = str()
        while sym not in ('\n', '\r', ' '):
            s += sym
            sym = self.read(1)

        return s

class Write():
    pass

class Number():
    def gcd(self, a, b):
        while b > 0:
            a, b = b, a % b
        return a
    
    def lcm(self, a, b):
        return a * b // gcd(a, b)

class Constants():
    EPS = 10 ** -9
    INF = 10 ** 18
    MOD = 10 ** 9 + 7

def solution(scan: Scan, write: Write):
    n, k = scan.integer(2)
    if k == 10 and n == 1:
        print(-1)
    else:
        if k == 10:
            print('1' * (n - 1) + str('0'))
        else:
            print(str(k) * n)

def main():
    queries: int = 1
    scan, write = Scan(), Write()
    #queries = scan.integer()
    for _ in range(queries):
        solution(scan, write)

if __name__ == "__main__":
    main()