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 ≤ 10^9, 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

Difficulty: MEDIUM

Starter code:

Solutions:
from math import gcd

def lcm(a, b):
	return a / gcd(a, b) * b
num = '1'
(n, k) = map(int, input().split())
for i in range(k):
	num += '0'
num = int(num)
print(int(lcm(num, n)))


a = [int(i) for i in input().split()]

def getLastNum(num):
	zeros = 0
	lastNum = num % 10
	num = str(num)
	for i in range(len(num) - 1, -1, -1):
		if num[i] == '0':
			zeros += 1
		else:
			lastNum = num[i]
			break
	return [int(lastNum), zeros]
(lastNum, zeros) = getLastNum(a[0])
x = a[0]
if zeros < a[1]:
	x = a[0] * 10 ** (a[1] - zeros)
possible = a[0]
hasfound = 0
while possible < x:
	(lastNum, zeros) = getLastNum(possible)
	if lastNum % 2 == 0 or lastNum % 5 == 0:
		if lastNum % 2 == 0:
			possible *= 5
		else:
			possible *= 2
		(lastNum, zeros) = getLastNum(possible)
		if zeros == a[1]:
			hasfound = 1
			break
	else:
		possible = possible * 10 ** (a[1] - zeros)
		break
if possible < x:
	print(possible)
else:
	print(x)


from math import gcd
(n, k) = list(map(int, input().split()))
print(10 ** k * n // gcd(10 ** k, n))


(n, k) = (int(x) for x in input().split())

def gcd(a, b):
	while a * b > 0:
		if a > b:
			a = a % b
		else:
			b = b % a
	return a + b
c = n
d = 10 ** k
ans = c * d / gcd(c, d)
print(int(ans))


(n, k) = input().split()
n = int(n)
k = int(k)
z = n
j = 0
i = 0
while z % 5 == 0:
	z = z / 5
	j += 1
z = n
while z % 2 == 0:
	z = z / 2
	i += 1
if k <= j and k <= i:
	print(n)
if k > j and k <= i:
	n = n * 5 ** (k - j)
	print(n)
if k <= j and k > i:
	n = n * 2 ** (k - i)
	print(n)
if k > j and k > i:
	n = n * 2 ** (k - i) * 5 ** (k - j)
	print(n)


(n, k) = list(map(int, input().split()))
res = [0, 0]
need = n
while need % 2 == 0 or need % 5 == 0:
	if need % 2 == 0:
		res[0] += 1
		need //= 2
	else:
		res[1] += 1
		need //= 5
if res[0] < k:
	two = 2 ** (k - res[0])
else:
	two = 1
if res[1] < k:
	five = 5 ** (k - res[1])
else:
	five = 1
print(n * two * five)


import math
(n, k) = map(int, input().split())
k = 10 ** k
print(n * k // math.gcd(n, k))


def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a

def lcm(a, b):
	return a * b / gcd(a, b)
(n, k) = map(int, input().split())
i = 10 ** k
print(int(lcm(n, i)))


(n, k) = list(map(int, input().split()))
k_ = 0
if n % 10 ** k == 0:
	print(n)
else:
	while n % 10 == 0:
		n //= 10
		k_ += 1
	while k_ < k:
		if n % 2 == 0:
			n //= 2
		elif n % 5 == 0:
			n //= 5
		else:
			break
		k_ += 1
	print(n * 10 ** k)


(n, k) = map(int, input().split())
k = 10 ** k
prz = n * k
while n != 0 and k != 0:
	if n > k:
		n = n % k
	else:
		k = k % n
nok = k + n
print(prz // nok)


(n, k) = map(int, input().split())
s = str(n)
cnt = 0
for i in s[::-1]:
	if i == '0':
		cnt += 1
	else:
		break
n //= 10 ** cnt
if cnt >= k:
	print(n * 10 ** cnt)
else:
	cnt2 = 0
	cnt5 = 0
	while n % 2 == 0:
		n //= 2
		cnt2 += 1
	while n % 5 == 0:
		n //= 5
		cnt5 += 1
	print(n * 10 ** k * 2 ** max(0, cnt2 - k + cnt) * 5 ** max(0, cnt5 - k + cnt))


(n, k) = map(int, input().split())
(a, b) = (10 ** k, 1)
while n % 2 == 0 and a % 2 == 0:
	(n, a, b) = (n // 2, a // 2, b * 2)
while n % 5 == 0 and a % 5 == 0:
	(n, a, b) = (n // 5, a // 5, b * 5)
print(n * a * b)


(n, k) = input().split()
n = int(n)
k = int(k)
temp = 1

def lcm(x, y):
	if x > y:
		greater = x
	else:
		greater = y
	while True:
		if greater % x == 0 and greater % y == 0:
			lcm = greater
			break
		greater += 1
	return lcm

def gcd(x, y):
	if x < y:
		temp = x
		x = y
		y = temp
	while y:
		(x, y) = (y, x % y)
	return x
if k == 0:
	print(n)
else:
	while k > 0:
		temp = temp * 10
		k = k - 1
	x = gcd(temp, n)
	temp = int(temp * n / x)
	print(temp)


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(n, k) = list(map(int, input().split()))
print(n // gcd(n, 10 ** k) * 10 ** k)


def nod(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a

def nok(a, b):
	return a * b // nod(a, b)
(n, k) = map(int, input().split())
print(nok(n, 10 ** k))


import sys
input = sys.stdin.readline
from math import ceil, floor, factorial

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

def int_array():
	return list(map(int, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
(n, k) = int_array()
pfs = primefs(n)
fives = pfs.get(5, 0)
twos = pfs.get(2, 0)
f = t = 0
if fives < k:
	f = k - fives
if twos < k:
	t = k - twos
ans = n * 2 ** t * 5 ** f
print(ans)


def divisorDeg(n, d):
	i = 0
	while n % d == 0:
		n = n // d
		i += 1
	return i
(n, k) = map(int, input().split())
deg2 = divisorDeg(n, 2)
deg5 = divisorDeg(n, 5)
ans = 2 ** max(k - deg2, 0) * 5 ** max(k - deg5, 0) * n
print(ans)


(n, i) = list(map(int, input().split()))
pi = pow(10, i)
x = n
p2 = 0
p5 = 0
while x % 2 == 0:
	x = x >> 1
	p2 += 1
while x % 5 == 0:
	x = x / 5
	p5 += 1
x = int(x) * pi
p2 -= i
p5 -= i
if p2 > 0:
	x *= 1 << p2
if p5 > 0:
	x *= pow(5, p5)
print(x)


def main():
	(n, k) = map(int, input().split())
	(x, two, five) = (n, k, k)
	while not x % 2:
		x //= 2
		two -= 1
	while not x % 5:
		x //= 5
		five -= 1
	print(n * 2 ** max(two, 0) * 5 ** max(five, 0))
main()


import math
l = input()
(n, k) = (int(s) for s in l.split())
print(int(10 ** k * n / math.gcd(n, 10 ** k)))


(n, k) = [int(x) for x in input().split()]
a = n
count2 = 0
count5 = 0
while a % 2 == 0 and count2 < k:
	a = a // 2
	count2 += 1
a = n
while a % 5 == 0 and count5 < k:
	a = a // 5
	count5 += 1
print(n * 2 ** (k - count2) * 5 ** (k - count5))


def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
(n, k) = map(int, input().split(' '))
print(int(n * 10 ** k / gcd(n, 10 ** k)))


import sys
from functools import reduce
I = sys.stdin.readline
(n, k) = map(int, I().split())

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def lcm(a, b):
	return a * b // gcd(a, b)
print(lcm(n, 10 ** k))


(x, y) = map(int, input().split())
k = 10 ** y
m = k * x
while x != 0 and k != 0:
	if x > k:
		x %= k
	else:
		k %= x
print(m // (k + x))


from fractions import gcd
(n, k) = map(int, input().split())
print(n * 10 ** k // gcd(n, 10 ** k))


from fractions import gcd
(n, k) = tuple(map(int, input().split()))
if k == 0:
	print(n)
else:
	print(n * 10 ** k // gcd(10 ** k, n))


(n, k) = input().split()
k = int(k)
n = int(n)
if k < 1:
	print(n)
	exit()
init = n
t = 0
while True:
	if n == 0:
		break
	if n % 2 == 0:
		t += 1
		n = n / 2
	else:
		break
l = 0
while True:
	if n == 0:
		break
	if n % 5 == 0:
		l += 1
		n = n / 5
	else:
		break
if t <= k:
	t = k - t
else:
	t = 0
if l <= k:
	l = k - l
else:
	l = 0
print(int(init * 2 ** t * 5 ** l))


(n, k) = map(int, input().split())
new_n = n
cnt_2 = 0
while new_n % 2 == 0:
	cnt_2 += 1
	new_n //= 2
cnt_5 = 0
while new_n % 5 == 0:
	cnt_5 += 1
	new_n //= 5
n *= 5 ** max(0, k - cnt_5)
n *= 2 ** max(0, k - cnt_2)
print(n)


(n, k) = map(int, input().split())
(twos, fives) = (0, 0)
while n % 5 == 0:
	n //= 5
	fives += 1
while n % 2 == 0:
	n //= 2
	twos += 1
ans = n * 10 ** k
if twos > k:
	ans *= 2 ** (twos - k)
if fives > k:
	ans *= 5 ** (fives - k)
print(ans)


def rec(i):
	nonlocal a
	return i
import sys
from collections import Counter
sys.setrecursionlimit(10 ** 6)
(a, b) = list(map(int, input().split()))
z = a
c = 0
while a % 5 == 0:
	c = c + 1
	a = a // 5
d = 0
while a % 2 == 0:
	d = d + 1
	a = a // 2
for i in range(b - c):
	z = z * 5
for i in range(b - d):
	z = z * 2
print(z)


import math
(a, b) = input().split()
a = int(a)
b = int(b)
ab = 1
for i in range(b):
	ab = ab * 10
print(ab // math.gcd(ab, a) * a)


(n, k) = map(int, input().split())
tc = 0
fc = 0
t = n
while t % 2 == 0:
	tc += 1
	t //= 2
while t % 5 == 0:
	fc += 1
	t //= 5
tc = max(0, k - tc)
fc = max(0, k - fc)
if tc != 0:
	n *= 2 ** tc
if fc != 0:
	n *= 5 ** fc
print(n)


(n, k) = map(int, input().split())
two = n
two_count = 0
five = n
five_count = 0
while True:
	if two % 2 == 0:
		two /= 2
		two_count += 1
	else:
		break
while True:
	if five % 5 == 0:
		five /= 5
		five_count += 1
	else:
		break
for i in range(k - five_count):
	n *= 5
for i in range(k - two_count):
	n *= 2
print(n)


(n, b) = map(int, input().split())
c = '1' + b * '0'
c = int(c)
k = n * c
while n != 0 and c != 0:
	if n > c:
		n = n % c
	else:
		c = c % n
print(k // (n + c))


(n, k) = map(int, input().split())
n1 = n
(a, b) = (0, 0)
while 1:
	if n % 5 == 0:
		n = n / 5
		a += 1
	else:
		break
while 1:
	if n % 2 == 0:
		n = n / 2
		b += 1
	else:
		break
print(5 ** max(0, k - a) * 2 ** max(0, k - b) * n1)


(n, z) = input().split()
n = int(n)
num = int(n)
z = int(z)
d = 2
jagob2 = 1
jagob5 = 1
result = {}
result[2] = 0
result[5] = 0
while d <= 5:
	count = 0
	while n % d == 0:
		count += 1
		n = n / d
	if count != 0:
		result[d] = count
	else:
		d = d + 3
if z - result[2] > 0:
	jagob2 = 2 ** (z - result[2])
if z - result[5] > 0:
	jagob5 = 5 ** (z - result[5])
print(jagob5 * jagob2 * num)


(n, k) = map(int, input().split(' '))
nf = 0
nt = 0
m = n
while m % 2 == 0:
	nt += 1
	m //= 2
m = n
while m % 5 == 0:
	nf += 1
	m //= 5
n *= 2 ** max(0, k - nt)
n *= 5 ** max(0, k - nf)
print(n)


(n, k) = [int(i) for i in input().split()]
t1 = 0
while t1 < k and n % 5 == 0:
	t1 += 1
	n //= 5
t1 = 0
while t1 < k and n % 2 == 0:
	t1 += 1
	n //= 2
print(n * 10 ** k)


(n, k) = input().split()
n = int(n)
k = int(k)
fixn = n
n2 = 0
n5 = 0
while n % 2 ** n2 == 0:
	n2 += 1
while n % 5 ** n5 == 0:
	n5 += 1
(n2, n5) = (n2 - min(n2, n5), n5 - min(n2, n5))
strn = str(n)
strn = strn[::-1]
zeros = 0
for i in strn:
	if i == '0':
		zeros += 1
	else:
		break
k -= zeros
k = max(k, 0)
while n2 != 0 and k != 0:
	n *= 5
	n2 -= 1
	k -= 1
while n5 != 0 and k != 0:
	n *= 2
	n5 -= 1
	k -= 1
n = str(n)
n += '0' * k
print(n)


(n, k) = input().split()
(k, n) = (int(k), int(n))
n1 = n
count2 = 0
while n1 % 2 == 0:
	n1 = n1 // 2
	count2 += 1
n1 = n
count5 = 0
while n1 % 5 == 0:
	n1 = n1 // 5
	count5 += 1
if k - count2 > 0:
	n *= 2 ** (k - count2)
if k - count5 > 0:
	n *= 5 ** (k - count5)
print(n)


def NOD(n1, n2):
	if n2 == 0:
		return n1
	else:
		return NOD(n2, n1 % n2)

def NOK(n1, n2):
	return n1 * n2 // NOD(n1, n2)
(n, k) = map(int, input().split())
a = 10 ** k
print(NOK(n, a))


(n, k) = map(int, input().split())
s = len(str(n)) - len(str(n).strip('0'))
for i in range(s, k):
	if str(n).strip('0')[-1] == '5':
		n *= 2
	elif str(n).strip('0')[-1] in '2468':
		n *= 5
	else:
		n *= 10
print(n)


(q, w) = list(map(int, input().split()))
(z, x) = (0, 0)
e = q
while e % 5 == 0:
	z += 1
	e //= 5
while e % 2 == 0:
	x += 1
	e //= 2
if w > z:
	z = w - z
else:
	z = 0
if w > x:
	x = w - x
else:
	x = 0
print(q * 5 ** z * 2 ** x)


(n, k) = list(map(int, input().split()))
(t, two, f, five) = (1, 2, 1, 5)
while True:
	if n % two == 0:
		t += 1
		two *= 2
	elif n % five == 0:
		f += 1
		five *= 5
	else:
		break
while t <= k:
	n *= 2
	t += 1
while f <= k:
	n *= 5
	f += 1
print(n)


(n, k) = map(int, input().split())
h = 10 ** k
g = 10 ** k * n
while h != 0 and n != 0:
	if h > n:
		h = h % n
	else:
		n = n % h
h = g // (h + n)
print(h)


(n, k) = list(map(int, input().split()))
a = n
c2 = 0
c5 = 0
while n % 5 == 0:
	n = n // 5
	c5 += 1
while n % 2 == 0:
	n = n // 2
	c2 += 1
c2 = k - c2
c5 = k - c5
c2 = c2 if c2 > 0 else 0
c5 = c5 if c5 > 0 else 0
print(a * 5 ** c5 * 2 ** c2)


import sys
LI = lambda : list(map(int, sys.stdin.readline().split()))
MI = lambda : map(int, sys.stdin.readline().split())
SI = lambda : sys.stdin.readline().strip('\n')
II = lambda : int(sys.stdin.readline())

def gcd(a, b):
	return b if a == 0 else gcd(b % a, a)
(n, k) = MI()
k = 10 ** k
print(n * k // gcd(n, k))


from fractions import *
(n, k) = map(int, input().split())

def get_answer(n, k):
	a = Fraction(10 ** k, n)
	return n * a.numerator

def nulls(s):
	s = str(s)
	return len(s) - len(s.rstrip('0'))
if nulls(n) >= k:
	print(n)
else:
	print(get_answer(n, k))


def lcm(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
(n, k) = input().split()
x = int(n)
y = int(k)
print(lcm(x, 10 ** y))


(n, k) = map(int, input().split())
a = n
c_2 = 0
c_5 = 0
for i in range(k):
	if n % 2 == 0 and c_2 < k:
		n //= 2
		c_2 += 1
	if n % 5 == 0 and c_5 < k:
		n //= 5
		c_5 += 1
n = a
c_2 = k - c_2
c_5 = k - c_5
print(n * 2 ** c_2 * 5 ** c_5)


num = input().split()
a = int(num[0])
b = 10 ** int(num[1])
while a != 0 and b != 0:
	if a > b:
		a = a % b
	else:
		b = b % a
print(int(num[0]) * 10 ** int(num[1]) // (a + b))


a = input()
(n, k) = a.split(' ')
n = int(n)
k = int(k)
pow2 = [1, 2, 4, 8, 16, 32, 64, 128, 256]
pow5 = [1, 5]
for i in range(2, 9):
	pow5.append(pow5[i - 1] * 5)
n1 = n
m5 = 0
m2 = 0
while n1 % 5 == 0:
	n1 = n1 / 5
	m5 += 1
n1 = n
while n1 % 2 == 0:
	n1 = n1 / 2
	m2 += 1
nd5 = k - m5
nd2 = k - m2
if nd2 < 0:
	nd2 = 0
if nd5 < 0:
	nd5 = 0
print(n * pow5[nd5] * pow2[nd2])


(n, k) = map(int, input().split())
i = 10
c = 0
while n % i == 0:
	i *= 10
	c += 1
n1 = n // 10 ** c
k -= c
k1 = k
k2 = k
if k <= 0:
	print(n)
else:
	while n1 % 5 == 0 and k1 > 0:
		n1 = n1 // 5
		k1 -= 1
	while n1 % 2 == 0 and k2 > 0:
		n1 = n1 // 2
		k2 -= 1
	print(str(n1) + '0' * (k + c))


from math import gcd
(n, k) = map(int, input().split())
l = abs(n * 10 ** k) // gcd(n, 10 ** k)
ans = 0
while True:
	ans += l
	if ans % n == 0:
		print(ans)
		break


(n, k) = [int(i) for i in input().split()]
kol2 = 0
kol5 = 0
n1 = n
while n1 % 5 == 0:
	n1 /= 5
	kol5 += 1
n1 = n
while n1 % 2 == 0:
	n1 /= 2
	kol2 += 1
while k - kol2 > 0:
	n *= 2
	kol2 += 1
while k - kol5 > 0:
	n *= 5
	kol5 += 1
print(n)


e = [int(x) for x in input().split()]
n = e[0]
k = e[1]
while n % 10 == 0:
	n //= 10
	k -= 1
two = 0
while n % 2 == 0:
	n //= 2
	two += 1
five = 0
while n % 5 == 0:
	n //= 5
	five += 1
if k <= 0:
	print(e[0])
else:
	n = e[0] * int(pow(10, k))
	if k >= two and k >= five:
		n //= int(pow(2, two) * pow(5, five))
	else:
		n //= int(pow(2, min(k, two)) * pow(5, min(k, five)))
	print(n)


def f(l):
	(n, k) = l
	e2 = 0
	e5 = 0
	while n % 2 ** e2 == 0:
		e2 += 1
	e2 -= 1
	while n % 5 ** e5 == 0:
		e5 += 1
	e5 -= 1
	return n * 2 ** max(0, k - e2) * 5 ** max(0, k - e5)
l = list(map(int, input().split()))
print(f(l))


def main():
	(n, k) = map(int, input().split())
	num_2 = 0
	num_5 = 0
	x = n
	while x % 2 == 0:
		num_2 += 1
		x //= 2
	while x % 5 == 0:
		num_5 += 1
		x //= 5
	num_2 = k - min(num_2, k)
	num_5 = k - min(num_5, k)
	print(n * 5 ** num_5 * 2 ** num_2)
main()


def gcd(a, b):
	if b:
		return gcd(b, a % b)
	return a
(n, k) = map(int, input().split())
power = 10 ** k
print(n * power // gcd(n, power))


(n, k) = input().split()
(n, k) = (int(n), int(k))
k_exponent = 10 ** k
quotient = n
while quotient % 2 == 0 and k_exponent % 2 == 0 and (k_exponent >= 2):
	quotient //= 2
	k_exponent //= 2
while quotient % 5 == 0 and k_exponent % 5 == 0 and (k_exponent >= 5):
	quotient //= 5
	k_exponent //= 5
print(n * k_exponent)


def lcm(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
inf = input().split()
x = int(inf[0])
y = int(inf[1])
print(lcm(x, 10 ** y))


(n, k) = input().split()
n = int(n)
k = int(k)
A = []
d = 2
n1 = n
while d * d <= n1:
	if n1 % d == 0:
		A.append(d)
		n1 //= d
	else:
		d += 1
if n1 > 1:
	A.append(n1)
A.sort()
n1 = n
k1 = k
c4 = 0
while n1 > 0:
	if n1 % 10 == 0:
		k1 -= 1
		c4 += 1
	else:
		break
	n1 /= 10
if k1 <= 0:
	print(n)
else:
	k2 = k1
	n1 = n
	for i in A:
		if i == 2:
			n1 *= 5
		if i == 5:
			n1 *= 2
		n3 = n1
		c3 = 0
		while n3 > 0:
			if n3 % 10 == 0:
				c3 += 1
			else:
				break
			n3 /= 10
		if c3 == k:
			break
	min1 = min(10 ** k1 * n, n1)
	A.reverse()
	k2 = k1
	n1 = n
	for i in A:
		if i == 2:
			n1 *= 5
			k2 -= 1
		if i == 5:
			n1 *= 2
			k2 -= 1
		n3 = n1
		c3 = 0
		while n3 > 0:
			if n3 % 10 == 0:
				c3 += 1
			else:
				break
			n3 /= 10
		if c3 == k:
			break
	min1 = min(min1, n1)
	mink = min1
	c = 0
	while mink > 0:
		if mink % 10 == 0:
			c += 1
		else:
			break
		mink /= 10
	if c >= k:
		print(min1)
	else:
		print(min1 * 10 ** (k - c))


(a, k) = input().split()
a = int(a)
k = int(k)
c = a
i = int(0)
j = int(0)
while a % 2 == 0:
	a = a // 2
	i = i + 1
a = c
while a % 5 == 0:
	a = a // 5
	j = j + 1
if i >= k:
	i = 0
else:
	i = k - i
if j >= k:
	j = 0
else:
	j = k - j
print(c * 2 ** i * 5 ** j)


(n, k) = [int(i) for i in input().split()]

def primfacs(n):
	i = 2
	primfac = []
	while i * i <= n:
		while n % i == 0:
			primfac.append(i)
			n = n / i
		i = i + 1
	if n > 1:
		primfac.append(n)
	return primfac
a = primfacs(n)
b = []
for i in range(k):
	b.append(2)
	b.append(5)
for i in range(len(a)):
	c = a[i]
	if a[i] in b:
		a[i] = 1
		b[b.index(c)] = 1
z = 1
for i in range(len(a)):
	if a[i] != 1:
		z *= a[i]
print(int(z * 10 ** k))


import math

def gcd(x, y):
	if y == 0:
		return x
	return gcd(y, x % y)

def lcm(x, y):
	return int(x / gcd(x, y) * y)
(n, m) = [int(x) for x in input().split()]
print(lcm(n, 10 ** m))


(n, k) = [int(x) for x in input().split()]
n1 = n
cnt5 = cnt2 = 0
for i in range(k):
	if n1 % 2 == 0:
		n1 //= 2
		cnt2 += 1
	else:
		break
for i in range(k):
	if n1 % 5 == 0:
		n1 //= 5
		cnt5 += 1
	else:
		break
if cnt2 >= k and cnt5 >= k:
	print(n)
else:
	print(n * 2 ** (k - cnt2) * 5 ** (k - cnt5))


def _gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a

def gcd(*numbers):
	result = 0
	if len(numbers) == 1:
		numbers = numbers[0]
	for number in numbers:
		result = _gcd(result, number)
	return result
(n, k) = list(map(int, input().split()))
print(n * 10 ** k // _gcd(n, 10 ** k))


(a, b) = map(int, input().split(' '))
aa = a
fives = 0
while a % 5 == 0:
	fives += 1
	a /= 5
twos = 0
while a % 2 == 0:
	twos += 1
	a /= 2
x = 1
if fives < b:
	x *= 5 ** (b - fives)
if twos < b:
	x *= 2 ** (b - twos)
print(x * aa)


from math import gcd
lcm = lambda a, b: a * b // gcd(a, b)
while 1:
	try:
		(n, k) = map(int, input().split())
		print(lcm(n, 10 ** k))
	except EOFError:
		break


(a, b) = map(int, input().split())
for i in range(b):
	if a % 2 == 0:
		a //= 2
	if a % 5 == 0:
		a //= 5
b = 10 ** b
print(a * b)


s = list(map(int, input().split()))
n = 10 ** s[1]

def NOD(x, y):
	while x != 0 and y != 0:
		if x > y:
			x = x % y
		else:
			y = y % x
	if x == 0:
		return y
	else:
		return x
NOK = s[0] * n // NOD(s[0], n)
print(NOK)


(n, k) = map(int, input().split())
start_n = n
div2 = k
div5 = k
while n % 5 == 0 and div5 > 0:
	div5 -= 1
	n //= 5
while n % 2 == 0 and div2 > 0:
	div2 -= 1
	n //= 2
print(start_n * 5 ** div5 * 2 ** div2)


n = input().split()
Number = int(n[0])
zeroes = int(n[1])
counter2 = 0
counter5 = 0
for i in range(zeroes):
	if Number % 5 == 0:
		Number /= 5
		counter5 += 1
	else:
		pass
	if Number % 2 == 0:
		Number /= 2
		counter2 += 1
	else:
		pass
print(int(n[0]) * 5 ** (zeroes - counter5) * 2 ** (zeroes - counter2))


import math
str = input().split()
n = int(str[0])
k = int(str[1])
print(n * 10 ** k // math.gcd(n, 10 ** k))


(n, k) = map(int, input().split())
c = 10 ** k
t = n
two = 0
five = 0
while t % 2 == 0:
	t = t // 2
	two += 1
while t % 5 == 0:
	t = t // 5
	five += 1
answ = n * 5 ** max(k - five, 0) * 2 ** max(k - two, 0)
print(answ)


(n, k) = map(int, input().split())
nn = n
two = 0
five = 0
while n % 2 == 0:
	n //= 2
	two += 1
while n % 5 == 0:
	n //= 5
	five += 1
for i in range(max(0, k - two)):
	nn *= 2
for i in range(max(0, k - five)):
	nn *= 5
print(nn)


import os
import sys
from io import BytesIO, IOBase
from math import gcd

def primefac(n):
	prime = []
	while n % 2 == 0:
		prime.append(2)
		n = n // 2
	p = n ** 0.5
	p = int(p) + 1
	for i in range(3, p):
		while n % i == 0:
			prime.append(i)
			n = n // i
	if n > 2:
		prime.append(n)
	return prime

def main():
	(n, k) = list(map(int, input().split()))
	num = 10 ** k
	g = gcd(n, num)
	num = n * num
	print(num // g)
BUFSIZE = 8192

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')
main()


(n, k) = map(int, input().split())
x = 10 ** k
if n > x:
	big = n
	small = x
else:
	big = x
	small = n
mod = -1
while mod != 0:
	mod = big % small
	big = small
	if mod != 0:
		small = mod
print(small * int(n / small) * int(x / small))


(n, k) = [int(x) for x in input().strip().split()]
cn2 = n
cn5 = n
cnt2 = 0
cnt5 = 0
while cn2 % 2 == 0:
	if cnt2 == k:
		break
	cn2 /= 2
	cnt2 += 1
while cn5 % 5 == 0:
	if cnt5 == k:
		break
	cn5 /= 5
	cnt5 += 1
ans = n * 2 ** (k - cnt2) * 5 ** (k - cnt5)
print(ans)


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def main():
	(n, k) = map(int, input().split())
	d = 10 ** k
	g = gcd(n, d)
	print(n * d // g)
main()


(n, k) = map(int, input().split())
k = 10 ** k
s = n * k
while n * k > 0:
	if n > k:
		n = n % k
	else:
		k = k % n
D = s // (n + k)
print(D)


s = input().split()
n = int(s[0])
k = int(s[1])

def f(a, b):
	while b:
		a %= b
		(a, b) = (b, a)
	return a
print(int(n * 10 ** k / f(n, 10 ** k)))


def nod(a, b):
	while a != 0 and b != 0:
		if a > b:
			a = a % b
		else:
			b = b % a
	return a + b
(n, k) = map(int, input().split())
k = 10 ** k
print(int(n * k / nod(n, k)))


from math import gcd
(number, zero) = list(map(int, input().split()))
a = pow(10, zero)
print(a * number // gcd(a, number))


def gcd(a, b):
	while b != 0:
		c = a % b
		a = b
		b = c
	return a
(n, k) = map(int, input().split())
delik = 10 ** k
great_del = gcd(n, delik)
print(n * delik // great_del)


def gcd(a, b):
	while b > 0:
		(a, b) = (b, a % b)
	return a

def lcm(x, y):
	return x * y // gcd(x, y)
l = [int(i) for i in input().split()]
(n, k) = l
if k != 0:
	print(lcm(n, 10 ** k))
else:
	print(lcm(n, 1))


(n, k) = input().split()
c = 0
ans = int(n)
k = int(k)
t = True
while c < k:
	l = len(n)
	i = 1
	c = 0
	while i <= l:
		if n[-i] == '0':
			c += 1
			if c >= k:
				t = False
		else:
			m = int(n[-i])
			break
		i += 1
	if t:
		if m % 2 == 0:
			ans *= 5
			n = str(ans)
		elif m == 5:
			ans *= 2
			n = str(ans)
		else:
			ans *= 10
			n = str(ans)
print(n)


from math import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
(n, k) = map(int, input().split())
print(lcm(n, 10 ** k))


from math import *
(a, b) = map(int, input().split(' '))
c = 10 ** b
print(int(a * c / gcd(a, c)))


def gsd(a, b):
	if b == 0:
		return a
	return gsd(b, a % b)
(n, k) = map(int, input().split())
print(n * (10 ** k // gsd(n, 10 ** k)))


(n, k) = list(map(int, input().split()))
if k != 0:
	while str(n)[-k:] != '0' * k:
		first = str(n).replace('0', '')[-1]
		if first == '5':
			n *= 2
		elif not int(first) % 2:
			n *= 5
		else:
			n *= 10
print(n)


def gcd(a, b):
	while b > 0:
		(a, b) = (b, a % b)
	return a

def lcm(a, b):
	return int(a * b / gcd(a, b))

def main():
	(n, k) = map(int, input().split())
	if 1 <= n <= pow(10, 9) and 0 <= k <= 8:
		print(lcm(n, pow(10, k)))
main()


a = input()
k = ''
n = ''
test = False
for i in a:
	if i == ' ':
		test = True
		continue
	if test:
		k += i
	else:
		n += i
k = int(k)
n = int(n)
delit = 1
del2 = 0
del5 = 0
while n > 1:
	if n % 5 == 0:
		n = n // 5
		del5 += 1
	elif n % 2 == 0:
		n = n // 2
		del2 += 1
	else:
		delit = n
		n = 1
rez = delit * pow(5, max(del5, k) - k) * pow(2, max(del2, k) - k) * pow(10, k)
print(rez)


import math
(a, b) = map(int, input().split())
d = a
cnt_2 = 0
cnt_5 = 0
while a % 2 == 0:
	a /= 2
	cnt_2 += 1
while a % 5 == 0:
	a /= 5
	cnt_5 += 1
umn = 1
cnt_2_raz = max(b - cnt_2, 0)
cnt_5_raz = max(b - cnt_5, 0)
while cnt_2_raz > 0:
	umn *= 2
	cnt_2_raz -= 1
while cnt_5_raz > 0:
	umn *= 5
	cnt_5_raz -= 1
print(d * umn)


(n, k) = map(int, input().split())
cnt = 0
while cnt < k:
	if n % 10 == 0:
		n /= 10
		cnt += 1
	elif n % 5 == 0:
		n *= 2
	elif n % 2 == 0:
		n *= 5
	else:
		n *= 10
n *= pow(10, cnt)
print(int(n))


def nok(a, b):
	c = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return c // (a + b)
nk = input().split()
(n, k) = (int(nk[0]), int(nk[1]))
print(nok(10 ** k, n))


def Gauss(g):
	w = g
	a = 0
	b = 0
	while w % 2 == 0:
		a += 1
		w = w // 2
	while w % 5 == 0:
		b += 1
		w = w // 5
	return (a, b)
(n, k) = input().split()
n = int(n)
k = int(k)
(d, e) = Gauss(n)
if d >= k and e >= k:
	print(n)
	exit()
if d < k and e >= k:
	while d < k:
		n *= 2
		d += 1
	print(n)
	exit()
if e < k and d >= k:
	while e < k:
		n *= 5
		e += 1
	print(n)
	exit()
if e < k and d < k:
	while e < k:
		n *= 5
		e += 1
	while d < k:
		n *= 2
		d += 1
	print(n)
	exit()


def HOK(a, b):
	return a * b // HOD(a, b)

def HOD(a, b):
	if b == 0:
		return a
	return HOD(b, a % b)
(c, k) = map(int, input().split())
print(HOK(max(c, 10 ** k), min(c, 10 ** k)))


def cnt_fact(n, v):
	ans = 0
	while n % v == 0 and n > 0:
		ans += 1
		n /= v
	return ans
(n, k) = map(int, input().split(' '))
print(n * 2 ** max(0, k - cnt_fact(n, 2)) * 5 ** max(0, k - cnt_fact(n, 5)))


(n, k) = map(int, input().split())
t = n
s = 0
while t % 10 == 0:
	s += 1
	t //= 10
if k <= s:
	print(n)
	exit()

def rec(r, k0):
	if k0 >= k:
		return r * 10 ** k
	if r % 10 == 0:
		return rec(r // 10, k0 + 1)
	elif r % 10 == 5:
		return rec(r * 2 // 10, k0 + 1)
	elif r % 2 == 0:
		return rec(r * 5 // 10, k0 + 1)
	else:
		return r * 10 ** k
print(rec(n, 0))


import math
(x, k) = map(int, input().split())
number_div = 10 ** k
print(x * number_div // math.gcd(number_div, x))


(n, m) = map(int, input().split())
col1 = 0
col2 = 0
c = n
while n % 2 == 0:
	col1 += 1
	n /= 2
while n % 5 == 0:
	col2 += 1
	n /= 5
if min(col1, col2) >= m:
	print(c)
else:
	print(c * 2 ** max(m - col1, 0) * 5 ** max(m - col2, 0))


import sys

def gcd(a, b):
	if b:
		return gcd(b, a % b)
	else:
		return a
for line in sys.stdin:
	(n, k) = [int(x) for x in line.strip().split()]
	i = 10 ** k
	b = i % n
	c = gcd(b, n)
	c = n // c
	print(c * i)


(k, n) = map(int, input().split())
s2 = 0
s5 = 0
for i in range(n):
	flag = False
	if k % 2 ** (i + 1) == 0:
		s2 += 1
		flag = True
	if k % 5 ** (i + 1) == 0:
		s5 += 1
		flag = True
	if not flag:
		break
print(k * 2 ** (n - s2) * 5 ** (n - s5))


(n, k) = map(int, input().split())
res = 1
n2 = n
cnt10 = 0
cnt2 = 0
cnt5 = 0
while n2 % 10 == 0:
	cnt10 += 1
	n2 /= 10
while n2 % 5 == 0:
	cnt5 += 1
	n2 /= 5
while n2 % 2 == 0:
	cnt2 += 1
	n2 /= 2
pow5 = max(k - cnt10 - cnt5, 0)
pow2 = max(k - cnt10 - cnt2, 0)
print(2 ** pow2 * 5 ** pow5 * n)


import sys, math

def factorization(num):
	res = dict()
	x = 2
	while x ** 2 <= num:
		while num % x == 0:
			if x in res:
				res[x] += 1
			else:
				res.update({x: 1})
			num //= x
		x += 1
	if num > 1:
		if num in res:
			res[num] += 1
		else:
			res.update({num: 1})
	return res
(n, k) = map(int, sys.stdin.readline().split())
now = factorization(n)
two = 0
five = 0
if 2 in now:
	two = now[2]
if 5 in now:
	five = now[5]
temp = min(two, five)
if temp >= k:
	need_two = k - five
	need_five = k - two
	if need_two <= 0 and need_five > 0:
		print(n * pow(2, need_five))
	elif need_two > 0 and need_five <= 0:
		print(n * pow(2, need_two))
	elif need_two <= 0 and need_five <= 0:
		print(n)
else:
	need_two = k - two
	need_five = k - five
	if need_two <= 0 and need_five > 0:
		print(n * pow(5, need_five))
	elif need_two > 0 and need_five <= 0:
		print(n * pow(2, need_two))
	elif need_two > 0 and need_five > 0:
		print(n * pow(2, need_two) * pow(5, need_five))


def rounding(n, k):
	(k1, k2, n1) = (0, 0, n)
	while n1 % 2 == 0:
		k1 += 1
		n1 //= 2
	while n1 % 5 == 0:
		k2 += 1
		n1 //= 5
	(k1, k2) = (k - min(k1, k), k - min(k2, k))
	return n * 5 ** k2 * 2 ** k1
(N, K) = [int(i) for i in input().split()]
print(rounding(N, K))


def nod(a, b):
	if b == 0:
		return a
	return nod(b, a % b)
(n, k) = map(int, input().split())
x = nod(n, 10 ** k)
print(n * 10 ** k // x)


(m, k) = list(map(int, input().split()))
n = m
twos = 0
fives = 0
while n % 2 == 0 or n % 5 == 0:
	if n % 2 == 0:
		twos += 1
		n //= 2
	if n % 5 == 0:
		fives += 1
		n //= 5
final = n * 2 ** max(k, twos) * 5 ** max(k, fives)
print(final)


def lcm(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
(n, k) = map(int, input().split())
k = pow(10, k)
print(lcm(n, k))


(n, k) = [int(i) for i in input().split(' ')]
for i in range(k):
	if n % 2 == 0:
		n = n // 2
	if n % 5 == 0:
		n = n // 5
ans = n * 10 ** k
print(ans)


def nok(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
a1 = input().strip().split()
a = int(a1[0])
b = int(a1[1])
print(nok(a, 10 ** b))


(n, k) = map(int, input().split())
ii = 0
jj = 0
while n % 5 ** jj == 0:
	jj += 1
ll = 0
while n % 2 ** ll == 0:
	ll += 1
ll -= 1
jj -= 1
ii += min(jj, ll)
if jj > ll:
	jj -= ll
	ll = 0
else:
	ll -= jj
	jj = 0
if k <= ii:
	print(n)
	quit()
k -= ii
if ll == 0:
	if jj >= k:
		print(n * 2 ** k)
		quit()
	k -= jj
else:
	if ll >= k:
		print(n * 5 ** k)
		quit()
	k -= ll
print(n * 2 ** jj * 10 ** k * 5 ** ll)


def ns(n, d):
	x = 0
	while not n % d:
		x += 1
		n //= d
	return x

def tozero(x):
	return x if x >= 0 else 0

def m(n, k):
	n5 = ns(n, 5)
	n2 = ns(n, 2)
	return n * 2 ** tozero(k - n2) * 5 ** tozero(k - n5)
(n, k) = map(int, input().split())
print(m(n, k))


from sys import stdin as fin
(n, k) = map(int, fin.readline().split())
(n_, cnt, m) = (n, 0, 1)
while not n % 10 and cnt < k:
	(n, cnt) = (n // 10, cnt + 1)
if n % 2:
	while not n % 5 and cnt < k:
		(n, cnt, m) = (n // 5, cnt + 1, m * 2)
else:
	while not n % 2 and cnt < k:
		(n, cnt, m) = (n // 2, cnt + 1, m * 5)
if cnt < k:
	m *= 10 ** (k - cnt)
print(n_ * m)


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a // gcd(a, b) * b
(a, b) = map(int, input().split())
b = 10 ** b
print(lcm(max(a, b), min(a, b)))


(n, x) = map(int, input().split())
t = n
i = 1
flag = 0
while True:
	if t // pow(10, x) >= 1 and t % pow(10, x) == 0:
		flag = 1
		break
	k = t % pow(10, i) // 10 ** (i - 1)
	if k == 0:
		pass
	elif k % 2 == 1 and k != 5:
		i = i - 1
		break
	elif k == 5:
		t = t * 2
	elif k % 2 == 0:
		t = t * 5
	i = i + 1
if flag == 1:
	print(t)
else:
	print(t * 10 ** max(x - i, 0))


(n, oc) = map(int, input().split())
k = 1
p = -1
while n % k == 0:
	p += 1
	k *= 2
k = 1
p5 = -1
while n % k == 0:
	p5 += 1
	k *= 5
if oc < p:
	p = 1
else:
	p = 2 ** (oc - p)
if oc < p5:
	p5 = 1
else:
	p5 = 5 ** (oc - p5)
print(int(n * p5 * p))


def gcd(x, y):
	while y:
		x %= y
		(x, y) = (y, x)
	return x

def lcm(x, y):
	return x // gcd(x, y) * y
(n, k) = map(int, input().split())
print(lcm(n, 10 ** k))


(n, m) = map(int, input().split())
two = 0
five = 0
t = n
while t % 2 == 0:
	t = t // 2
	two += 1
while t % 5 == 0:
	t = t // 5
	five += 1
print(n * 2 ** max(m - two, 0) * 5 ** max(m - five, 0))


(n, k) = map(int, input().split())
p = n
for i in range(k):
	if p % 5 == 0:
		p //= 5
	if p % 2 == 0:
		p //= 2
print(p * 10 ** k)


(a, b) = map(int, input().split())

def gcd(x, y):
	while x > 0:
		(x, y) = (y % x, x)
	return y

def nok(x, y):
	return x * y // gcd(x, y)
print(nok(a, 10 ** b))


(n, k) = input().split()
k = int(k)
n = int(n)
a = n
b = 10 ** k
if n % 10 == 5 or n % 10 == 0 or n % 2 == 0:
	while a % 2 == 0 and b % 2 == 0:
		a = a // 2
		b = b // 2
	while a % 5 == 0 and b % 5 == 0:
		a = a // 5
		b = b // 5
	a = n * b
else:
	a = a * 10 ** k
print(a)


(n, k) = map(int, input().split())
k = 10 ** k
a = n * k
while n * k != 0:
	if n > k:
		n = n % k
	else:
		k = k % n
print(a // (k + n))


def nok(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
(n, k) = list(map(int, input().split()))
print(nok(n, 10 ** k))


from fractions import gcd

def lcm(a, b):
	return a * b // gcd(a, b)
(n, k) = map(int, input().split())
p = 10 ** k
print(lcm(p, n))


(n, k) = map(int, input().split())
(del_two, del_five) = (-k, -k)
while n % 2 == 0:
	del_two += 1
	n //= 2
while n % 5 == 0:
	del_five += 1
	n //= 5
n *= 10 ** k
if del_two > 0:
	n *= 2 ** del_two
if del_five > 0:
	n *= 5 ** del_five
print(n)


(n, k) = list(map(int, input().split()))
pow5 = len([5 ** d for d in range(1, 10) if n % 5 ** d == 0])
pow2 = len([2 ** d for d in range(1, 10) if n % 2 ** d == 0])
print(n * 5 ** max(k - pow5, 0) * 2 ** max(k - pow2, 0))


t = 1
for qwe in range(t):
	(n, k) = map(int, input().split())
	n1 = n
	cten = 0
	cfive = 0
	ctwo = 0
	while n % 10 == 0:
		n //= 10
		cten += 1
	while n % 5 == 0:
		n //= 5
		cfive += 1
	while n % 2 == 0:
		n //= 2
		ctwo += 1
	if cten >= k:
		print(n1)
	else:
		k -= cten
		if cfive != 0:
			if cfive >= k:
				n1 *= 2 ** k
			else:
				n1 *= 2 ** cfive
				k -= cfive
				n1 *= 10 ** k
		elif ctwo != 0:
			if ctwo >= k:
				n1 *= 5 ** k
			else:
				n1 *= 5 ** ctwo
				k -= ctwo
				n1 *= 10 ** k
		else:
			n1 *= 10 ** k
		print(n1)


import math

def get_lcm(n1, n2):
	gcd = math.gcd(n1, n2)
	result = n1 * n2 / gcd
	return result

class CodeforcesTask858ASolution:

	def __init__(self):
		self.result = ''
		self.n_k = []

	def read_input(self):
		self.n_k = [int(x) for x in input().split(' ')]

	def process_task(self):
		self.result = str(int(get_lcm(self.n_k[0], 10 ** self.n_k[1])))

	def get_result(self):
		return self.result
Solution = CodeforcesTask858ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


(n, k) = [int(i) for i in input().split(' ')]
a = n * 10 ** k
a2 = a
a5 = a
count2a = 0
count5a = 0
while a2 % 2 == 0:
	a2 /= 2
	count2a += 1
while a5 % 5 == 0:
	a5 /= 2
	count5a += 1
while a % 10 ** k == 0 and a % n == 0:
	a = a / 2
	count2a -= 1
if a % 10 ** k != 0 or a % n != 0:
	a *= 2
while a % 10 ** k == 0 and a % n == 0:
	a = a / 5
	count5a -= 1
if a % 10 ** k != 0 or a % n != 0:
	a *= 5
print(int(a))


import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

def inlist():
	return list(map(int, input().split()))

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def factorize(n):
	limit = int(sqrt(n) + 1)
	res = []
	for i in range(2, limit + 1):
		while n % i == 0:
			res.append(i)
			n //= i
	if n > 1:
		res.append(n)
	return res
(n, k) = invr()
a = factorize(n)
five = a.count(5)
two = a.count(2)
if five >= k:
	if two >= k:
		print(n)
	else:
		gun = k - two
		print(n * 2 ** gun)
else:
	fgun = k - five
	tgun = 0
	if two < k:
		tgun += k - two
	print(n * 5 ** fgun * 2 ** tgun)


from math import gcd
(n, k) = map(int, input().split())
lcm = lambda a, b: a * b // gcd(a, b)
print(lcm(n, 10 ** k))


import math
(n, k) = list(map(int, input().split()))
tmp = n
z = 0
while n % 10 == 0:
	n = n // 10
	z += 1
k = k - z
if k <= 0:
	print(tmp)
else:
	last = n % 10
	v = int(math.pow(10, k))
	if last == 5:
		i = 2
		cur = n
		while cur % v != 0:
			cur = n * i
			i += 2
		print(int(cur * math.pow(10, z)))
	elif last % 2 == 1:
		print(tmp * v)
	else:
		i = 5
		cur = n
		while cur % v != 0:
			cur = n * i
			i += 5
		print(int(cur * math.pow(10, z)))


(n, k) = map(int, input().split())
s = int(str(n))
c = 0
v = 0
while n % 5 == 0:
	n = n // 5
	c += 1
while n % 2 == 0:
	n = n // 2
	v += 1
d = min(v, c)
l = max(v, c)
if d >= k:
	print(s)
elif l >= k:
	if l == v:
		s = s * 5 ** (k - d)
		print(s)
	elif l == c:
		s = s * 2 ** (k - d)
		print(s)
else:
	s = s * 5 ** (k - c) * 2 ** (k - v)
	print(s)


def nulls(n):
	data = list(str(n))
	iter = 0
	for i in range(len(data) - 1, -1, -1):
		if data[i] != 0:
			break
		iter += 1
	return iter

def sol():
	(n, am) = list(map(int, input().split()))
	if am == 0:
		print(n)
		return 0
	deviders = [n, 1]
	iter = 2
	while iter * iter <= n:
		if iter * iter != n:
			if n % iter == 0:
				deviders.append(iter)
				deviders.append(n // iter)
		elif n % iter == 0:
			deviders.append(iter)
		iter += 1
	vars = []
	for i in range(len(deviders)):
		nullsEnd = nulls(deviders[i])
		number = int(str(deviders[i]) + '0' * max(0, am - nullsEnd))
		if number % n == 0:
			vars.append(number)
	print(min(vars))
sol()


(n, k) = map(int, input().split())
d = 10 ** k
p = n * d
while d:
	(d, n) = (n % d, d)
print(p // n)


(a, b) = list(map(int, input().split()))
c = a
while c % a != 0 or c % 10 ** b != 0:
	d = c
	while d % 10 == 0:
		d = d // 10
	if d % 10 == 1 or d % 10 == 3 or d % 10 == 7 or (d % 10 == 9):
		c = c * 10
	elif d % 10 == 5:
		c = c * 2
	else:
		c = c * 5
print(c)


(n, k) = list(map(int, input().split()))
five = 0
two = 0
while n % 5 ** five == 0:
	five += 1
while n % 2 ** two == 0:
	two += 1
five -= 1
two -= 1
two_left = k - two
five_left = k - five
if two_left > 0:
	n *= 2 ** two_left
if five_left > 0:
	n *= 5 ** five_left
print(n)


(n, k) = map(int, input().split())
(p2, p5) = (0, 0)
while not n % 2 ** (p2 + 1):
	p2 += 1
while not n % 5 ** (p5 + 1):
	p5 += 1
if p2 < k:
	n *= 2 ** (k - p2)
if p5 < k:
	n *= 5 ** (k - p5)
print(n)


import math

def lcm(a, b):
	return a * b // math.gcd(a, b)
(a, b) = map(int, input().split())
kpop = 10 ** b
print(lcm(a, kpop))


import math
(n, k) = list(map(int, input().split()))
t = 1
for i in range(k):
	t *= 10
print(n * t // math.gcd(n, t))


(n, k) = map(int, input().split())
a = 10 ** k
m = n * a
while n != 0 and a != 0:
	if n > a:
		n %= a
	else:
		a %= n
else:
	b = m // (n + a)
print(b)


(n, k) = map(int, input().split())
m = n
a2 = 0
a5 = 0
while m % 2 == 0:
	m //= 2
	a2 += 1
while m % 5 == 0:
	m //= 5
	a5 += 1
b2 = max(0, k - a2)
b5 = max(0, k - a5)
n *= 2 ** b2 * 5 ** b5
print(n)


import math

def ria():
	return [int(i) for i in input().split()]
(n, k) = ria()
g = math.gcd(n, 10 ** k)
print(n * 10 ** k // g)


import sys

def lcm(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
(number, zero_count) = map(int, sys.stdin.readline().split())
zero_number = int('1' + '0' * zero_count)
i = 1
print(lcm(zero_number, number))


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(n, k) = map(int, input().split())
l = 1
for i in range(k):
	l *= 10
print(str(n // gcd(n, l)) + '0' * k)


import math
inp = input()
inp = inp.split(' ')
n = int(inp[0])
k = int(inp[1])
st = 10 ** k
NOD = math.gcd(n, st)
NOK = n * st / NOD
print(int(NOK))


def NOD(a, b):
	while a != 0:
		c = b % a
		b = a
		a = c
	return b
(n, k) = map(int, input().split())
A = n
B = 10 ** k
N = NOD(A, B)
NOK = A * B // N
print(NOK)


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a // gcd(a, b) * b

def main():
	(n, k) = map(int, input().split())
	x = 10 ** k
	print(n // gcd(n, x) * x)
main()


(n, k) = map(int, input().split())
x = n
i = 2
c2 = 0
c5 = 0
while i * i <= n:
	if n % i == 0:
		cnt = 0
		while n % i == 0:
			n = n // i
			cnt += 1
		if i == 2:
			c2 = cnt
		elif i == 5:
			c5 = cnt
			break
	i += 1
if n != 0 and n == 2:
	c2 = 1
elif n != 0 and n == 5:
	c5 = 1
if c2 >= k and c5 >= k:
	print(x)
else:
	if k - c2 > 0:
		result = x * 2 ** (k - c2)
	else:
		result = x
	if k - c5 > 0:
		result = result * 5 ** (k - c5)
	print(result)


import sys
import math
import itertools
import collections

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)

def ii():
	return int(input())

def mi():
	return map(int, input().split())

def li():
	return list(map(int, input().split()))

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def wr(arr):
	return ' '.join(map(str, arr))

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)
(n, k) = mi()
if n % 10 ** k == 0:
	print(n)
else:
	two = five = 0
	while n % 5 == 0:
		n //= 5
		five += 1
	while n % 2 == 0:
		n //= 2
		two += 1
	print(n * 2 ** max(two, k) * 5 ** max(five, k))


def max_power(x, s):
	c = 0
	t = x
	while t % s == 0:
		t //= s
		c += 1
	return c
(n, k) = map(int, input().split())
c2 = max_power(n, 2)
c5 = max_power(n, 5)
x = max(0, k - c2)
y = max(0, k - c5)
a = 2 ** x * 5 ** y
print(n * a)


import math

def main():
	inp = input().split()
	n = int(inp[0])
	k = int(inp[1])
	number_of_twos = 0
	number_of_fives = 0
	tens = 0
	aux_n = n
	while aux_n % 2 == 0:
		aux_n /= 2
		number_of_twos += 1
	aux_n = n
	while aux_n % 5 == 0:
		aux_n /= 5
		number_of_fives += 1
	while number_of_fives > 0 and number_of_twos > 0:
		tens += 1
		number_of_fives -= 1
		number_of_twos -= 1
	while tens < k:
		if number_of_fives > 0:
			number_of_fives -= 1
			n *= 2
		elif number_of_twos > 0:
			number_of_twos -= 1
			n *= 5
		else:
			n *= 10
		tens += 1
	print(n)
main()


from math import *

def chop():
	return (int(i) for i in input().split())

def nok(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
(n, k) = chop()
print(nok(n, 10 ** k))


(n, k) = map(int, input().split())
(n2, n5) = (n, n)
(k2, k5) = (0, 0)
while n2 % 2 == 0:
	k2 += 1
	n2 = n2 // 2
while n5 % 5 == 0:
	k5 += 1
	n5 = n5 // 5
print(n * 2 ** max(k - k2, 0) * 5 ** max(k - k5, 0))


from fractions import gcd
(n, k) = [int(x) for x in input().split()]
s = gcd(n, 10 ** k)
print(n * 10 ** k // s)


def main():
	(n, k) = map(int, input().split())
	if n % 10 ** k == 0:
		print(n)
		return
	(b2, b5) = (0, 0)
	x = n
	while x % 2 == 0:
		x = x // 2
		b2 += 1
	x = n
	while x % 5 == 0:
		x = x // 5
		b5 += 1
	k -= min(b2, b5)
	if b2 > b5:
		if b2 - b5 > k:
			print(n * 5 ** k)
		else:
			print(n * 5 ** (b2 - b5) * 10 ** (k - b2 + b5))
	elif b5 - b2 > k:
		print(n * 2 ** k)
	else:
		print(n * 2 ** (b5 - b2) * 10 ** (k - b5 + b2))
main()


c = [int(q) for q in input().split()]
n = c[0]
k = c[1]
a = 1
i = 0
while n % 10 == 0:
	if i >= k:
		break
	n /= 10
	a *= 10
	i += 1
while n % 5 == 0:
	if i >= k:
		break
	n /= 5
	a *= 10
	i += 1
while n % 2 == 0:
	if i >= k:
		break
	n /= 2
	a *= 10
	i += 1
while i < k:
	i += 1
	a *= 10
print(int(n * a))


def main():
	(n, k) = (int(x) for x in input().split())
	solver(n, k)

def solver(n, k):
	fives = findPow(n, 5)
	twos = findPow(n, 2)
	ans = n * 5 ** max(0, k - fives) * 2 ** max(0, k - twos)
	print(ans)

def findPow(n, k):
	count = 0
	while n % k == 0:
		n //= k
		count += 1
	return count
main()


def myfunc(n, k):
	for i in range(k):
		if n % 2 == 0:
			n //= 2
		if n % 5 == 0:
			n //= 5
	return n * 10 ** k
A = list(map(int, input().split()))
print(myfunc(A[0], A[1]))


(n, k) = map(int, input().split())
ni = n
nb5 = 0
nb2 = 0
while n % 5 == 0:
	nb5 += 1
	n //= 5
while n % 2 == 0:
	nb2 += 1
	n //= 2
nb2 = max(0, k - nb2)
nb5 = max(0, k - nb5)
print(ni * 5 ** nb5 * 2 ** nb2)


(n, k) = map(int, input().split())
a = b = k
while n % 5 ** a:
	a -= 1
while n % 2 ** b:
	b -= 1
print(n * 5 ** (k - a) * 2 ** (k - b))


(a, b) = map(int, input().split())
twos = 0
fives = 0
t = a
while not t % 2:
	t //= 2
	twos += 1
t = a
while t % 5 == 0:
	t //= 5
	fives += 1
if fives > twos:
	b -= min(twos, b)
	fives -= twos
	print(a * 2 ** min(b, fives) * 10 ** (b - min(b, fives)))
else:
	b -= min(fives, b)
	twos -= fives
	print(a * 5 ** min(b, twos) * 10 ** (b - min(b, twos)))


(n, k) = map(int, input().split())

def getCount(y):
	count = 0
	while y > 0:
		if y % 10 == 0:
			count += 1
		y = y / 10
	return count
x = n
while getCount(x) < k:
	a = x // 10 ** getCount(x)
	a = str(a)[-1]
	if a == '3' or a == '7' or a == '10' or (a == '9'):
		x = x * 10
	elif a == '2' or a == '4' or a == '6' or (a == '8'):
		x = x * 5
	else:
		x = x * 2
print(x)


def HOD(a, b):
	(a, b) = (max(a, b), min(a, b))
	while b > 0:
		(a, b) = (b, a % b)
	return a
(n, k) = map(int, input().split())
print(n * 10 ** k // HOD(n, 10 ** k))


def findnumber(i, n):
	amount = 0
	while n % i == 0:
		amount += 1
		n //= i
	return amount
(n, k) = map(int, input().split())
if k > findnumber(2, n):
	n *= 2 ** (k - findnumber(2, n))
if k > findnumber(5, n):
	n *= 5 ** (k - findnumber(5, n))
print(n)


(n, k) = map(int, input().split())
ans = 1
f = 0
ans *= n
for i in range(k, -1, -1):
	if f != 1:
		if n % 2 != 0:
			ans *= 2 ** i
			if f == 0:
				f = 1
			else:
				break
		else:
			n //= 2
	if f != 2:
		if n % 5 != 0:
			ans *= 5 ** i
			if f == 0:
				f = 2
			else:
				break
		else:
			n //= 5
print(ans)


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
(a, b) = M()
k = a
c = 0
d = 0
while a % 2 == 0:
	a //= 2
	c += 1
while a % 5 == 0:
	a //= 5
	d += 1
if c < b:
	k *= 2 ** (b - c)
if d < b:
	k *= 5 ** (b - d)
print(k)


def gcd(a, b):
	if b == 0:
		return a
	a = a % b
	(a, b) = (b, a)
	return gcd(a, b)
(n, k) = map(int, input().split())
ans = n * 10 ** k // gcd(n, 10 ** k)
print(ans)


(n, k) = map(int, input().split())
c2 = 0
c5 = 0
n1 = n
while n % 2 == 0:
	c2 += 1
	n //= 2
while n % 5 == 0:
	c5 += 1
	n //= 5
n = n1
while c2 < k:
	n *= 2
	c2 += 1
while c5 < k:
	n *= 5
	c5 += 1
print(n)


from math import gcd

def lcm(x, y):
	ans = x * y // gcd(x, y)
	return ans
(n, k) = map(int, input().split())
if k == 0:
	print(n)
else:
	z = 10 ** k
	print(lcm(n, z))


def c0(x):
	c = 0
	while x % 10 == 0:
		c += 1
		x = int(x / 10)
	ld = x
	return (c, ld)
(n, k) = map(int, input().split())
(c, d) = c0(n)
k -= c
c = 10 ** c
while k > 0:
	if not d * 2 % 10:
		d = int(d / 5)
	elif not d * 5 % 10:
		d = int(d / 2)
	c *= 10
	k -= 1
print(d * c)


(n, m) = map(int, input().split())
k = 10 ** m
c = k * n
while n != 0 and k != 0:
	if n > k:
		n = n % k
	else:
		k = k % n
c = c // (k + n)
print(c)


import math
[n, k] = list(map(int, input().split()))
lcm = lambda x, y: x * y / math.gcd(max(x, y), min(x, y))
print(int(lcm(n, pow(10, k))))


(n, k) = map(int, input().split())
gcd = lambda a, b: a if b == 0 else gcd(b, a % b)
d = 10 ** k
p = d * n // gcd(n, d)
print(p)


(x, y) = map(int, input().split())
j = x
res = 0
while x % 5 == 0:
	x //= 5
	res += 1
if res < y:
	j *= 5 ** (y - res)
res = 0
while x % 2 == 0:
	x //= 2
	res += 1
if res < y:
	for n in range(y - res):
		j *= 2
print(j)


(n, k) = map(int, input().split())
i = 0
j = 0
s = n
while s % 2 == 0 or s % 5 == 0:
	if s % 2 == 0:
		s = s // 2
		i += 1
	elif s % 5 == 0:
		s = s // 5
		j += 1
if i > k and j > k:
	print(n)
elif i > k:
	print(n * 5 ** (k - j))
elif j > k:
	print(n * 2 ** (k - i))
else:
	print(n * 2 ** (k - i) * 5 ** (k - j))


a = list(map(int, input().split()))
n = a[0]
k = a[1]
total = n
d5 = 0
d2 = 0
while n % 5 == 0:
	n /= 5
	d5 += 1
while n % 2 == 0:
	n /= 2
	d2 += 1
if d5 < k:
	total *= 5 ** (k - d5)
if d2 < k:
	total *= 2 ** (k - d2)
print(total)


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
BUFSIZE = 8192

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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from math import sqrt, floor, factorial, gcd, log
from collections import deque, Counter, defaultdict
from itertools import permutations
from math import gcd
from bisect import bisect
input = lambda : sys.stdin.readline().rstrip('\r\n')
read = lambda : list(map(int, input().strip().split(' ')))

def solve():
	(n, k) = read()
	dic = {5: 0, 2: 0}
	t = n
	for i in dic:
		c = 0
		while n % i == 0:
			c += 1
			n //= i
		dic[i] = c
	for i in dic:
		t *= i ** max(0, k - dic[i])
	print(t)
solve()


(i, k) = map(int, input().split())
basei = i
n5 = 0
n2 = 0
while i % 2 == 0:
	i = i // 2
	n2 += 1
while i % 5 == 0:
	i = i // 5
	n5 += 1
print(basei * 2 ** max(0, k - n2) * 5 ** max(0, k - n5))


def r(n):
	t = 0
	f = 0
	while n % 2 == 0:
		t += 1
		n //= 2
	while n % 5 == 0:
		f += 1
		n //= 5
	return (t, f)
(n, k) = map(int, input().split())
(t, f) = r(n)
ans = n * 10 ** k
ans //= 5 ** min(f, k)
ans //= 2 ** min(t, k)
print(ans)


(n, k) = [int(i) for i in input().split()]
if k == 0:
	print(n)
else:
	f = 0
	t = 0
	n2 = n
	n3 = n
	while n2 % 2 == 0:
		t += 1
		n2 = n2 / 2
	n2 = int(n2)
	while n2 % 5 == 0:
		f += 1
		n2 = n2 / 5
	while f < k:
		n *= 5
		f += 1
	while t < k:
		n *= 2
		t += 1
	print(n)


def lcm(a, b):
	m = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return m // (a + b)
(x, y) = [int(i) for i in input().split()]
a = 1
for i in range(0, y):
	a *= 10
print(str(lcm(x, a)))


from sys import maxsize, stdout, stdin, stderr
mod = int(1000000000.0 + 7)

def tup():
	return map(int, stdin.readline().split())

def I():
	return int(stdin.readline())

def lint():
	return [int(x) for x in stdin.readline().split()]

def S():
	return input().strip()

def grid(r, c):
	return [lint() for i in range(r)]

def debug(*args, c=6):
	print('\x1b[3{}m'.format(c), *args, '\x1b[0m', file=stderr)
from math import log2, sqrt
from collections import Counter, defaultdict
from itertools import permutations
import re
from math import floor, sqrt, ceil
from math import gcd

def kround():
	(n, k) = tup()
	(a, b) = (n, pow(10, k))
	l = a * b // gcd(a, b)
	print(l)
kround()


(n, k) = map(int, input().split())
nn = n
while nn % 10 == 0 and k > 0:
	nn /= 10
	k -= 1
while nn % 5 == 0 and k > 0:
	n *= 2
	nn /= 5
	k -= 1
while nn % 2 == 0 and k > 0:
	n *= 5
	nn /= 2
	k -= 1
while k > 0:
	n *= 10
	k -= 1
print(n)


(n, k) = map(int, input().split())
st5 = 0
st2 = 0
x = 1
n0 = n
while n % 5 == 0:
	n = n // 5
	st5 += 1
while n % 2 == 0:
	n = n // 2
	st2 += 1
if st5 < k:
	x *= 5 ** (k - st5)
if st2 < k:
	x *= 2 ** (k - st2)
print(x * n0)


(n, k) = map(int, input().split())
if k == 0:
	print(n)
else:
	n1 = n
	k = 10 ** k
	k1 = k
	while n > 0 and k > 0:
		if n > k:
			n = n % k
		else:
			k = k % n
	if n == 0:
		nod = k
	else:
		nod = n
	nok = n1 * k1 // nod
	print(nok)


import math
(n, k) = map(int, input().split())
d = 10 ** k
h = math.gcd(n, d)
l = n * d // h
print(l)


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')
main()


(n, k) = map(int, input().split())

def nok(a, b):
	l = a * b
	while a != 0 and b != 0:
		if a > b:
			a %= b
		else:
			b %= a
	return l // (a + b)
print(nok(n, int('1' + '0' * k)))


import sys
input = sys.stdin.readline
import bisect
from math import *

def bo(i):
	return ord(i) - ord('a')
(n, k) = map(int, input().split())
p = n
c2 = 0
c5 = 0
while p % 2 == 0:
	c2 += 1
	p //= 2
while p % 5 == 0:
	c5 += 1
	p //= 5
for i in range(c2, k):
	n *= 2
for i in range(c5, k):
	n *= 5
print(n)


def gcd(a, b):
	while b > 0:
		(a, b) = (b, a % b)
	return a

def lcm(a, b):
	s = a * b / gcd(a, b)
	return s
(n, k) = map(int, input().split())
x = 10 ** k
print(int(lcm(n, x)))


def gcd(a, b):
	while b != 0:
		(a, b) = (b, a % b)
	return a
(n, k) = map(int, input().split())
n1 = n
k1 = k
a = n1 // gcd(n, 10 ** k) * 10 ** k1
print(a)


(n, k) = map(int, input().split())
n1 = n
while n1 % 10 == 0:
	n1 //= 10
	k -= 1
if k == 0:
	print(n)
else:
	f = 0
	while n1 % 2 == 0:
		n1 //= 2
		n *= 5
		k -= 1
		if k == 0:
			print(n)
			f = 1
			break
	if f == 0:
		while n1 % 5 == 0:
			n1 //= 5
			n *= 2
			k -= 1
			if k == 0:
				print(n)
				f = 1
				break
	if f == 0:
		while k > 0:
			n *= 10
			k -= 1
		print(n)


(a, b) = map(int, input().split())
m = a
n = 10 ** b
r = 10 ** b
while r != 0:
	(a, r) = (r, a % r)
l = m * n / a
print('{:1.0f}'.format(l))


(n, k) = map(int, input().split())
new_n = n
_5 = 0
_2 = 0
while not n % 5:
	n //= 5
	_5 += 1
while not n % 2:
	n //= 2
	_2 += 1
count_5 = k - _5
count_2 = k - _2
for i in range(count_5):
	new_n *= 5
for i in range(count_2):
	new_n *= 2
print(new_n)


import math
(a, b) = input().split()
(a, b) = (int(a), int(b))
c = 10 ** b

def nod(a, b):
	if b == 0:
		return a
	return int(nod(b, a % b))
print(int(c * a / nod(c, a)))


def GCD(a, b):
	if b > a:
		(a, b) = (b, a)
	while not b == 0:
		(a, b) = (b, a % b)
	return a

def LCM(c, d):
	e = c * d
	return e / GCD(c, d)
(n, k) = input().strip().split()
v = 10 ** int(k)
print(int(LCM(int(n), v)))


(n, k) = map(int, input().split())
temp = n
count5 = 0
count2 = 0
while temp % 5 == 0:
	temp //= 5
	count5 += 1
while temp % 2 == 0:
	temp //= 2
	count2 += 1
if count5 < count2:
	n *= 5 ** min(-count5 + count2, abs(k - count5))
elif count5 > count2:
	n *= 2 ** min(-count2 + count5, abs(k - count2))
print(n * 10 ** max(0, k - max(count2, count5)))


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def lcm(a, b):
	return a * b / gcd(a, b)
m = []
s = []
(n, k) = map(int, input().split(' '))
print(int(lcm(n, 10 ** k)))


(n, k) = map(int, input().split())
(z, p) = (k, n)
while n:
	if not n % 2 and k:
		k -= 1
		n //= 2
	elif not n % 5 and z:
		z -= 1
		n //= 5
	else:
		break
print(p * 2 ** k * 5 ** z)