peterverebics/CodeNet_Python_118 huggingface dataset:
import math
N, K = map(int, input().split())
A_list = [int(i) for i in input().split()]

index = A_list.index(1)

left_list = A_list[:index]
right_list = A_list[index+1:]

if len(left_list) < K-1:
  left_count = 1
  right_list = right_list[(K-1-len(left_list)):]
  right_count = math.ceil(len(right_list) / (K-1))
else:
  left_count = math.ceil(len(left_list) / (K-1))
  right_count = math.ceil(len(right_list) / (K-1))

print(left_count + right_count)
N, K = list(map(int, input().split()))
numlist = list(map(int, input().split()))
front = N - (numlist.index(1))
print(front // (K - 1) + (numlist.index(1) + 1) // (K-1))
n, k = map(int, input().split())

count = 1
if n > k:
    for i in range(k - 1, n, k - 1):
        count += 1

print(count)
n, k = map(int, input().split())
A = list(map(int, input().split()))

p = A.index(1)
if p == 0 or p == n-1:
  ans = n // 2
elif p == 1 or p == n-2:
  ans = 1 + (n-2) // 2
else:
  ans = (p + 1) // 2 + (n - p + 1) // 2

print(ans)
from math import ceil

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

if k >= n:
    print(1)
    exit()

i = a_list.index(1)
ans = ceil(i / (k - 1)) + ceil((n - 1 - i) / (k - 1))
print(ans)
import math

N, K = map(int, input().split())
A = [int(i) for i in input().split()]    
minA = [i for i,a in enumerate(A) if a==1][0]
print(math.ceil(len(A[:minA])/(K-1)) + math.ceil(len(A[minA+1:])/(K-1)))
n,k = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
if n%(k-1) == 0:
    print(n//(k-1))
elif n == k:
    print('1')
else:
    print(n//(k-1)+1)
import math
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))
for i in range(N):
    if A[i] == 1:
        ind = i
        break
left = ind
right = N - ind - 1
ans = 0
if left:
    temp = K - 1
    while(1):
        ans += 1
        if temp >= left:
            break
        temp += K - 1
if right:
    temp = K - 1
    while(1):
        ans += 1
        if temp >= right:
            break
        temp += K - 1

print(ans)
import math
N, K = map(int,input().split())
A = list(map(int,input().split()))
print(int((N-1)/(K-1)))
from math import ceil
n,k=map(int,input().split())
a=list(map(int,input().split()))
idx=-1
b=10**18
for i in range(n):
  if b>a[i]:
    idx=i
    b=a[i]
print(ceil(idx/(k-1))+ceil((n-idx-1)/(k-1)))
n,k=map(int, input().split())
a=list(map(int,input().split()))
m=n%k
print(n//k+m)
import sys
import math

N, K = map(int, input().split())

ans = math.ceil(N / (K-1))
print(ans)
import numpy as np
n, k = map(int, input().split())
A = list(map(int, input().split()))
a = np.argmin(A)
print((a)//(k-1)+(n-a)//(k-1))
n, k = map(int, input().split())
a = list(map(int, input().split()))

x = n//(k-1) + 1
print(x)
N, K = map(int, input().split())
A = list(map(int, input().split()))

if N == K:
    print(1)
    exit()

q, r = divmod(N, K - 1)

if r == 0:
    print(q)
else:
    print(q + 1)
n,k=map(int,input().split())
a=list(map(int,input().split()))
s=min(a)
x=[-1]
for i in range(n):
    if a[i]==s:
        x.append(i)
x.append(n)
X=len(x)
ans=0
for i in range(X-1):
    y=(x[i+1]-x[i]-1)//(k-1)
    if (x[i+1]-x[i]-1)%(k-1)!=0:
        y+=1
    ans+=y
print(ans)
def LI():
	return [ int(s) for s in input().split() ]
  
N,K = LI()
A = LI()

for idx,a in enumerate(A):
    if a == 1:
      min_index = idx
      break
      
if N - idx+1 > K and idx+1 > K:
  cnt = 0
  if (N-idx+1)%K == 0:
    cnt += (N-idx+1)//K
  else:
    cnt += (N-idx+1)//K + 1
  if (idx+1)%K == 0:
    cnt += (idx+1)//K
  else:
    cnt += (idx+1)//K + 1
else:
  print(N//K + 1) if N%K != 0 else print(N//K)
from math import ceil
n,k=map(int,input().split())
if n <= k:
  print(1)
  quit()
A=list(map(int,input().split()))
ind = A.index(1)
ans = ceil((ind)/(k-1))+ceil((n-ind)/(k-1))
print(ans)
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))

minpos = 0
for i in range(0, n):
  if a[i] == 1: minpos = i
print((minpos + k - 2) // (k - 1) + (n - minpos - 1 + k - 2) // (k - 1))
n, k = map(int, input().split())
a = list(map(int, input().split()))

one = 0
for i in range(n):
    if a[i] == 1:
        one = i + 1
        break
    
print(-( -(one - 1) // (k - 1)) + -( -(n - one) // (k - 1)))
# -*- coding: utf-8 -*-
# モジュールのインポート
import math

# 標準入力を取得
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

# 求解処理
x = A.index(1)
y = N - x - 1
ans = math.ceil(x / (K - 1)) + math.ceil(y / (K - 1))

# 結果出力
print(ans)
import math
N, K = map(int, input().split())
a = list(map(int, input().split()))
ans = math.ceil(N / (K - 1))
print(ans)
import numpy as np
N,K = map(int,input().split())
an = list(map(int,input().split()))

min_an_index = np.argmin(an)

a = min_an_index
b = N - min_an_index - 1

if K < a:
    b -= K - a
if K < b:
    a -= K - b
    
a1 = a // (K-1)
if a % (K-1) != 0:
    a1 += 1
    
b1 = b // (K-1)
if b % (K-1) != 0:
    b1 += 1

count = a1 + b1
print(count)
import math
n,k = map(int,input().split())
a = list(map(int,input().split()))
s = a.index(1)
left = s
right = n - (s + 1)
print(math.ceil(left / (k-1)) + math.ceil(right / (k-1)))
n,k=map(int,input().split())
r=list(map(int,input().split()))
a=r.index(1)
b=n-a-1
print((a+k-1)//k+(b+k-1)//k)
n,k = map(int, input().split( ))
*a, = map(int, input().split( ))

i = a.index(1)

if (i-1)%(k-1)+(n-i)%(k-1)==k-1:##
    print((n-1)//(k-1))
else:
    print((n-1)//(k-1)+1)
N, K = map(int, input().split())
A = list(map(int, input().split()))
print(N//(K-1))
D, N = map(int, input().split())

ans = N * 100 ** D

if N == 100:
    ans += 100 ** D

print(ans)
d,n=map(int,input().split())
print(n*100**d if n!=100 else 101*100**d)
from itertools import count


def count_div_by_100(n: int) -> int:
    for idx in range(4):
        q, r = divmod(n, 100)
        if r != 0:
            return idx
        n //= 100
    return -1


D, N = map(int, input().split())
current = 0
current_idx = 0
for n in count(start=1):
    if count_div_by_100(n) == D:
        current = n
        current_idx += 1
    if current_idx == N:
        print(current)
        break
d, n = map(int, input().split())

div = 100 ** d

if n < 100:
    print(div * n)
    exit(0)
else:
    print(div * 101)
    exit(0)
D,N=map(int,input().split())
if N==100:
    N+=1
print(N*(100**D))
D,N = map(int,input().split())
if N!=100:
    ans = N*100**D
else:
    ans = 101*100**D 

print(ans)
D, N = map(int,input().split())
if D == 0:
    if N < 100:
        print(N)
    else:
        print(101)
elif D == 1:
    if N < 100:
        print(N*100)
    else:
        print(10100)
else:
    if N < 100:
        print(N*10000)
    else:
        print(1010000)
from itertools import permutations

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

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

def main():
    D, N = mi()
    if N == 100:
        print(100**D*101)
    else:
        print(100**D*N)

if __name__ == '__main__':
    main()
d, n = map(int, input().split())
if n == 100:
    print(100 ** d * 101)
else:
    print(100 ** d * n)
D,N=map(int,input().split());print(100**D*[N,101][N>99])
d,n = map(int,input().split())
if n == 100:
  print(101*(100**d))
else:
  print(n*(100**d))
D, N = map(int, input().split())

if N == 100:
    if D == 0:
        print(101)
    elif D == 1:
        print(10100)
    else:
        print(1010000)
elif D == 0:
    print(N)
elif D == 1:
    print(100 * N)
else:
    print(10000 * N)
d,n=map(int,input().split())
if d==0:
  if n==100:
    ans=101
  else:
    ans=n
elif d==1:
  if n==100:
    ans=10100
  else:
    ans=n*100
else:
  if n==100:
    ans=1010000
  else:
    ans=n*10000
print(ans)
def resolve():
    D, N = map(int, input().split())
    if D == 0:
        if N == 100:
            print("101")
        else:
            print(N)
    elif D == 1:
        if N == 100:
            print("10100")
        else:
            print(100*N)
    else:
        if N == 100:
            print("1010000")
        else:
            print(10000*N)
resolve()
A = []
B = []
C = []

for i in range(1,101):
    t0 = i
    t1 = i*100
    t2 = i*100*100
    A.append(t0)
    B.append(t1)
    C.append(t2)

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

if d == 0:
    if n == 100:
        print(101)
    else:
        print(A[n-1])
elif d == 1:
    if n == 100:
        print(100*101)
    else:
        print(B[n-1])
else:
    if n == 100:
        print(100*100*101)
    else:
        print(C[n-1])
D,N = list(map(int, input().split()))
if N == 100: N += 1
print(N*(100**D))
A,N=map(int, input().split())
if N<100:
  print(N*100**A)
else:
  print(101*100**A)
d, n = map(int, input().split())
if n == 100:
  print(100**d*101)
else:
  print(100**d*n)
D, N = map(int, input().split())

if N < 100:
    ans = N * 100 ** D
else:
    ans = N * 100 ** D + 100**D
print(ans)
D,N = map(int,(input().split()))
l = [[] for _ in range(3)]
for i in range(1,1010001):
    c = 0
    j = i
    while j%100 == 0:
        c += 1
        j //= 100
    if c < 3:
        l[c].append(i)

print(l[D][N-1])
d,n = map(int,input().split())
if n == 100:
    print(101 * 100**d)
else:
    print(n * 100**d)
D,N = [int(i) for i in input().split()]
print(N*100**D if N != 100 else (N+1)*100**D)
D,N=map(int,input().split())
if N!=100:
    print(N*(100**D))
else:
    print((N+1)*(100**D))
d, n = [int(x) for x in input().split()]

x = 100 ** d

if n == 100:
    n = 101

ans = n * x
print(ans)
d,n = map(int,input().split())
ans = n * 100**d
if n == 100:
    ans += 100**d
print(ans)
D,N=map(int,input().split())
print(((100**D)*N) if N<100 else ((N+1)*(100**D)))
def read_ints():
    return[int(i) for i in input().split()]

def main():
    d, n = read_ints()
    print(101 * (100**d) if n == 100 else (100**d)*n)

if __name__ == '__main__':
    main()
d, n = map(int,input().split())
if n== 100:
  n+=1
print(n*(100**d))
d,n = map(int, input().split())
 
if d == 0:
    if n < 100:
        print(n)
    else:
        print(101)    
elif d == 1:
    if n < 100:
        print(n*100)
    else:
        print(10100)
elif d == 2:
    if n < 100:
        print(n*10000)
    else:
        print(n*10000+10000)
def main():
    d,n = map(int, input().split())
    if n == 100:
        print((100**d) * (n+1)) 
    else:
        print((100**d) * n)  
if __name__ == '__main__':
    main()
D, N = map(int, input().split())
if D > 0:
  if N < 100:
    print( N * 100**D )
  else:
    print( 101 * 100**D )
if D == 0:
  if N < 100:
    print(N)
  else:
    print(101)
D,N = map(int,input().split())
if N == 100:
  N += 1
print(N*(100**D))
d, n = map(int, input().split())
if n == 100:
    print(max(100 ** d, 1) * n + 100**d)
else:
    print(max(100 ** d, 1) * n)
d, n = map(int, input().split())
 
if d == 0:
    if n != 100:
        print(n)
    else:
        print(n + 1)
elif d == 1:
    if n != 100:
        print(n * 100)
    else:
        print(n * 100 + 100)
else:
    if n != 100:
        print(n * 10000)
    else:
        print(n * 10000 + 10000)
d,n=map(int,input().split())
x=n*(100**d)
print(x if n%100!=0 else x+(100**d))
# -*- coding: utf-8 -*-
d, n = map(int,input().split())

if d == 0:
    if n <= 99:
        print(n)
    else:
        print(101)
if d == 1:
    if n <= 99:
        print(n * 100)
    else:
        print(10100)
if d == 2:
    if n <= 99:
        print(n * 10000)
    else:
        print(1010000)
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7

d, n = MAP()
m = 100 ** d * n
if n == 100:
    m = 100 ** d * 101
print(m)
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)

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

if n != 100:
    print((100 ** d) * n)
else:
    print((100 ** d) * (n + 1))
[D,N] = list(map(int,input().split()))
if N!=100:
    print(100**D*N)
else:
    print(100**D*(N+1))
def main():
    d, n = map(int, input().split())
    answer = 100 ** d
    if 0 < d:
        while 0 < n:
            if answer % (100 ** d) == 0 and answer % (100 ** (d + 1)) > 0:
                n -= 1
            answer += 100 ** d
        answer -= 100 ** d
    else:
        answer = n if n < 100 else 101
    print(answer)


if __name__ == '__main__':
    main()
d, n = map(int, input().split())
ans = (100**d)*n
if n == 100:
  ans += 100**d
print(ans)
import sys
def input(): return sys.stdin.readline().strip()

def resolve():
    d,n=map(int, input().split())
    if n!=100:
        print(100**d*n)
    elif n==100:
        print(100**d*101)
resolve()
D, N = map(int, input().split())
if N != 100:
  if D == 0:
    print(N)
  elif D == 1:
    x = [100 * i for i in range(1, 101)]
    print(x[N-1])
  elif D == 2:
    x = [10000 * i for i in range(1, 101)]
    print(x[N-1])
else:
  if D == 0:
    print(101)
  elif D == 1:
    x = [100 * i for i in range(1, 101)]
    print(x[N-1]+100)
  elif D == 2:
    x = [10000 * i for i in range(1, 101)]
    print(x[N-1]+10000)
d, n = map(int, input().split())

if n == 100:
    ans = (100**d)*(n+1)
else:
    ans = (100**d)*n
print(ans)
d,n = map(int,input().split())
if n == 100:
    n += 1
print(100 ** d * n)
D, N = map(int, input().split())

D = 100 ** D
if N<= 99:
    print(D*N)
else:
    print(D*101)
d,n = map(int,input().split())
if n == 100:
    print(100**d*(101))
else:
    print(100**d*n)
d,n = map(int, input().split())
if d == 0:
    if n != 100:
        print(n)
    else:
        print(101)
    
elif d == 1:
    if n != 100:
        print(n*100)
    else:
        print(10100)
elif d == 2:
    if n != 100:
        print(n*10000)
    else:
        print(1010000)
d,n=map(int,input().split())
print(10**(2*d)*(n+n//100))
d, n = map(int, input().split())
cnt = 0
i = 0
while cnt < n:
  i += 1
  if i % 100**d == 0 and i % 100**(d+1) != 0:
    cnt += 1
print(i)
D, N = map(int, input().split())

def calc(n):
    count = 0
    while n % 100 == 0:
        count += 1
        n /= 100
    return count

count = 0
val = 0
while count < N:
    val += 1
    if calc(val) == D:
        count += 1

print(val)
d,n=map(int,input().split())
if n<100:
    print(n*100**d)
else:
    print(101*100**d)
def main():
    import sys
    input = sys.stdin.readline
    D, N = map(int, input().split())
    if N != 100:
        print(N, end="")
        for i in range(D):
            print("00", end="")
        print("")
    else:
        print(100 ** (D+1) + 100 ** D)

if __name__ == '__main__':
    main()
D,N=map(int,input().split())
A=100**D
ans=N*A
if N==100:
    ans=101*A
print(ans)
d, n = map(int, input().split())
if n < 100:
  ans = n * 100**d
  print(ans)
else:
  ans = 101 * 100**d
  print(ans)
D, N = map(int,input().split())

if D == 0 and N != 100:
    print(N)
if D == 0 and N == 100:
    print(101)
if D == 1 and N != 100:
    print(N*100)
if D == 1 and N == 100:
    print(10100)
if D == 2 and N != 100:
    print(N*10000)
if D == 2 and N == 100:
    print(1010000)
A,B=map(int,input().split())
if B==100:
  print((100**A)*101)
  exit()
print((100**A)*B)
d, n = map(int, input().split())
x = 100 ** d
y = x
cnt = 0
while cnt < n:
    if y % 100**(d+1) != 0:
        cnt += 1
    y += x
print(y-x)
D,N=map(int, input().split())
m=0
for i in range(1, 10**10):
    c=0
    n=i
    while i%100==0:
        i//=100
        c+=1
    if c==D:
        m+=1
        if m==N:
            print(n)
            exit()
D, N = map(int, input().split())

if N != 100:
    print(100**D * N)
else:
    print(100**D * (N+1))
d,n=map(int,input().split())
if n==100:
    if d==0:
        print("101")
    elif d==1:
        print("10100")
    else:
        print("1010000")
else:
    print(100**d*n)
# -*- coding: utf-8 -*-
# 標準入力を取得
D, N = list(map(int, input().split()))

# 求解処理
ans = (N + (N // 100)) * 100**D

# 結果出力
print(ans)
x, y = map(int, input().split())
if x == 0:
    if y == 100:
        print(101)
    else:
        print(y)
elif x == 1:
    if y == 100:
        print(10100)
    else:
        print(y*100)
else:
    if y == 100:
        print(1010000)
    else:
        print(y*10000)
d,n=map(int,input().split())
if n==100:n+=1
print(100**d*n)
D,N = map(int,input().split())
if N == 100:
#need to skip 100 since 100 can be divided by 100 therefore D becomes D+1
    N = 101
print(100**D*N)
n=list(map(int, input().split()))

if n[1]==100:
  print((n[1]+1)*(100**n[0]))
else:
  print(n[1]*(100**n[0]))
D, N = map(int, input().split())
print(N*(100**D) if N != 100 else (N + 1)*(100**D))
D,N=map(int,input().split())
print(100**D * N if N !=100 else 100**D*101)
A,B=map(int,input().split())
if B==100:
  C=100**A*(B+1)
else:
  C=100**A*B
print(C)
d, n = map(int, input().split())

if n < 100:
    print(n * 100**d)
else:
    print(101 * 100**d)
d,n = map(int,input().split())
ans = 0
if n != 100:
  ans = 100**d * n
else:
  ans = 100**d * 101
print(ans)
D, N = map(int, input().split())

if N == 100:
    print(101 * 100**D)
else:
    print(N * 100**D)
D, N = map(int, input().split())
print((100 ** D) * 101 if N == 100 else (100 ** D) * N)
d,n = map(int,input().split())
if n != 100:
    print(100**d * n)
else:
    print(100**d * n + 100**d)
D,N=map(int,input().split())
print(100**D*N if N!=100 else 100**D*101)
a,b= map(int,input().split())
if b !=100:
  print((100 ** a)*b)
else:
  print((100 ** a)*(b+1))
d, n = map(int,input().split())
print( (n+1)*100**d if n%100==0 else n*100**d)
d,n = map(int,input().split())
case = 100**d
if n < 100:
    print(case*n)
else:
    print(101*case)
# -*- coding: utf-8 -*-
d, n = map(int,input().split())

if d == 0:
    if n < 100:
        print(n)
    if n == 100:
        print(101)
if d == 1:
    if n < 100:
        print(n * 100)
    if n == 100:
        print(10100)
if d == 2:
    if n < 100:
        print(n * 10000)
    if n == 100:
        print(1010000)
a, b = list(map(int, input().split()))

if b != 100:
  ans = 100 ** a * b
else:
  ans = 100 ** a * (b+1)

print(ans)
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil
from operator import itemgetter
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
inf = 10**17
mod = 10**9 + 7


d,n=MI()
ans=100**d*(n+n//100)
print(ans)
D,N = map(int,input().split())

if N != 100:
    print(N*pow(100,D))
else:
    print(101*pow(100,D))
d,n = map(int,input().split())
if n != 100:
    print(100**d*n)
else:
    print(100**d*101)
def main():
    D, N = map(int, input().split())
    h = 100
    if N == 100:
        print((100**D)*101)
    else:
        print((100 ** D)*N)
main()
d, n = map(int, input().split())
print(n * (100 ** d) if n < 100 else (n + 1) * (100 ** d) )
D, N = map(int, input().split())
if N == 100:
    ans = 100 ** D * (N+1)
else:
    ans = 100 ** D * N
print(ans)
d, n = map(int, input().split())
if n == 100:
  n += 1
print((100**d)*n)
D,N=map(int, input().split())
d = 1
for i in range(D):
  d *= 100
if N==100:
  N += 1
print(d*N)
D, N = map(int, input().split())

if N != 100:
  print(100**D*N)
else:
  print(100 ** D * 101)
a,b = map(int,input().split())
num = 100**a
ans = num*b
if b!= 100:
  print(ans)
else:
  print(ans+num)
D, N = map(int, input().split())

if N == 100:
    N += 1
print(100**D * N)
d,n=map(int,input().split())
ans=n*100**d
if n!=100:
    print(ans)
else:
    print(ans+1*100**d)
D, N=map(int, input().split())
a=0
if N==100:
  a=100**D
print((100**D)*N+a)
d,n = map(int,input().split())
a = 100**d
if n != 100:
    print(a*n)
else:
    print(a*(n+1))
d,n=map(int,input().split())
minus=n//100
print((n+minus)*(100**d))
import sys

def resolve():
    D, N = list(map(int, input().split(" ")))
    if D == 0:
        if N == 100:
            print(101)
        else:
            print(N)
    if D == 1:
        if N == 100:
            print(100*101)
        else:
            print(100*N)
    if D == 2:
        if N == 100:
            print(10000*101)
        else:
            print(10000*N)    

if '__main__' == __name__:
    resolve()
d,n = map(int, input().split())
print(100**d * (n+(n==100)) if d > 0 else (n + (n==100)))
n,m=map(int,input().split())
if(m<100):
  print(100**n*m)
else:
  print(100**n*101)
d, n = map(int, input().split())
if n == 100:
    print(101*100**d)
else:
    print(100**d*n)
D, N = map(int, input().split())

count = 0
for i in range(1, 10 ** 7):
    tmp = i
    flag = True
    div_count = 0
    for j in range(3):
        if tmp%100 == 0:
            tmp = tmp // 100
            div_count += 1

    if div_count == D:
        count += 1

    if count == N:
        print(i)
        break
d, n = map(int, input().split())

if d == 0:
    if n == 100:
        print(101)
    else:
        print(n)
elif d == 1:
    if n == 100:
        print(10100)
    else:
        print(n*100)
else:
    if n == 100:
        print(1010000)
    else:
        print(n*10000)
D, N = map(int, input().split())
if N == 100:
    N = 101
if D == 0:
    print(N)
elif D == 1:
    print(N*100)
else:
    print(N*10000)
D,N=map(int, input().split())
print((N+int(N/100))*100**D)
def main():
    D, N = map(int, input().split(" "))
    answer = 100 ** D * N
    i = 1
    flag = True
    while flag:
        if not answer % 100 ** (D + i):
            answer += 100 ** D
        else:
            flag = False
    print(answer)


if __name__ == '__main__':
    main()
D, N = map(int, input().split())

d = 100 ** D

if N == 100:
    N = 101
print(d * N)
d, n = map(int, input().split())

if(d == 0):
    print(n if n < 100 else n+1)
else:
    print(100**d * n if n < 100 else 100**d * (n+1))
d,n=map(int,input().split())
if(n!=100):
  print(100**d*n)
if(n==100):
  print(100**d*(n+1))
d, n = map(int, input().split())
print(100 ** d * (n + n // 100))
D, N = map(int,input().split())

cnt = 0

for i in range(1, 1500000):
    if i%(100**D) == 0 and  i%(100**(D+1)) != 0:
        cnt += 1
        if cnt == N:
            print(i)
            break
a, b = map(int, raw_input().split())
ans = 1
for i in range(a):
    ans = ans * 100
if b == 100:
    print ans * 101
else:
    print ans * b
import math
def main():
  d,n = list(map(int,input().split()))
  if n==100:
    n+=1
  print(pow(100,d)*n)
main()
d, n = map(int, input().split())
arr = []
i = 1
while len(arr) != n:
  if 100 ** d * i % 100 ** (d + 1) != 0:
    arr.append(100 ** d * i)
  i += 1
print(arr[-1])
d,n = map(int, input().split())

if n == 100: print(100**d*101)
else: print(100**d*n)
D,N=list(map(int,input().split()))
if D==0:
    if N==100:
        print(101)
        exit()
    print(N)
elif D==1:
    if N==100:
        print(100*101)
        exit()
    print(100*N)
else:
    if N==100:
        print(100*100*101)
        exit()
    print(100*100*N)
D,N = map(int,input().split())
A = [int(i) for i in range(1,100)] + [101]
B = [int(i*100) for i in range(1,100)] + [10100]
C = [int(i*10000) for i in range(1,100)] + [1010000]

if D == 0:
	print(A[N-1])
elif D == 1:
	print(B[N-1])
else:
	print(C[N-1])
def resolve():
    d, n = map(int, input().split())
    if d == 0:
        if n == 100:
            print(101)
        else:
            print(n)
    elif d == 1:
        if n == 100:
            print(10100)
        else:
            print(n*100)
    else:
        if n == 100:
            print(1010000)
        else:
            print(n*10000)
resolve()
d, n = map(int, input().split())
print(100**d * (n + n//100))
D, N = map(int, input().split())

if(N == 100):
	N = 101
print(100**D*N)
D,N = map(int,input().split())
print(N*100**D if N<100 else 101*100**D)
D,N = map(int, input().split())
ans = (N+N//100)*100**D
print(ans)