For a given positive integer n denote its k-rounding as the minimum positive integer x, such that x ends with k or more zeros in base 10 and is divisible by n.

For example, 4-rounding of 375 is 375·80 = 30000. 30000 is the minimum integer such that it ends with 4 or more zeros and is divisible by 375.

Write a program that will perform the k-rounding of n.

Input

The only line contains two integers n and k (1 ≤ n ≤ 109, 0 ≤ k ≤ 8).

Output

Print the k-rounding of n.

Examples

Input

375 4


Output

30000


Input

10000 1


Output

10000


Input

38101 0


Output

38101


Input

123456789 8


Output

12345678900000000
# cook your code here
import os
import sys
from math import ceil, floor, sqrt, gcd, factorial, log
from io import BytesIO, IOBase
from collections import Counter
from itertools import permutations, combinations
import bisect

BUFSIZE = 8192

def prime(n):
    i=2
    while(i*i<=n):
        if n%i==0:
            return False
        i+=1
    return True
    
def five(n):
    i=0
    while(n>=1):
        if n%5==0:
            i+=1
            n=n//5
        else:
            return i
            
def two(n):
    i=0
    while(n>=1):
        if n%2==0:
            i+=1
            n=n/2
        else:
            return i

def main():
    n,k=map(int,input().split())
    manipulandum=str(n)
    s10=len(manipulandum)-len(manipulandum.rstrip('0'))
    if s10>=k:print(n)
    else:
        k-=s10
        s5=five(n)
        s2=two(n)
        extra5=max(0,s5-s2)
        extra2=max(0,s2-s5)
        if extra2==0 and extra5==0:
            print(n*(10**k))
        elif extra2==0:
            r=min(k,extra5)
            print(n*(2**r)*(10**(k-r)))
        else:
            r=min(k,extra2)
            print(n*(5**r)*(10**(k-r)))


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)

class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")

sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == "__main__":
    main()
