Problem:
 Score: 200 points    Problem Statement  Today, the memorable AtCoder Beginner Contest 100 takes place. On this occasion, Takahashi would like to give an integer to Ringo. As the name of the contest is AtCoder Beginner Contest 100, Ringo would be happy if he is given a positive integer that can be divided by 100  exactly  D times.  Find the N -th smallest integer that would make Ringo happy.      Constraints   D is 0 , 1 or 2 .  N is an integer between 1 and 100 (inclusive).         Input  Input is given from Standard Input in the following format:  D  N       Output  Print the N -th smallest integer that can be divided by 100 exactly D times.        Sample Input 1 0 5      Sample Output 1 5  The integers that can be divided by 100 exactly 0 times (that is, not divisible by 100 ) are as follows: 1 , 2 , 3 , 4 , 5 , 6 , 7 , ... Thus, the 5 -th smallest integer that would make Ringo happy is 5 .       Sample Input 2 1 11      Sample Output 2 1100  The integers that can be divided by 100 exactly once are as follows: 100 , 200 , 300 , 400 , 500 , 600 , 700 , 800 , 900 , 1 \ 000 , 1 \ 100 , ... Thus, the integer we are seeking is 1 \ 100 .       Sample Input 3 2 85      Sample Output 3 850000  The integers that can be divided by 100 exactly twice are as follows: 10 \ 000 , 20 \ 000 , 30 \ 000 , ... Thus, the integer we are seeking is 850 \ 000 .

Solution (Python):
a, b = map(int, input().split())
if b % 100 == 0:
  print(100 ** a * (b + 1))
else:
  print(100 ** a * b)

Solution (Python):
D,N = map(int, input().split())
if N < 100:
  print(N*100**D)
else:
  print(101*100**D)

Solution (Python):

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




if n == 100: n+= 1
print(100 ** d * n)

Solution (Python):
D, N = map(int, input().split())

def chk(n):
    result = 0
    while  n % 100 == 0:
        n = int(n/100)
        result += 1
    return result

ans = 1
cnt = 0
while True:
    d = chk(ans)
    if d == D:
        cnt += 1
    if d == D and cnt == N:
        break
    ans += 1

print(ans)

Solution (Python):
d, n = map(int, input().split())

if n != 100:
    print((100**d) * n)
else:
    print((100**d) * 101)

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

Solution (Python):
d,n=map(int,input().split())

if n<100:
    print(100**d*n)

elif n==100:
    print(100**d*101)

Solution (Python):
d,n=map(int,input().split())

if n==100:
    print(101*100**d)

else:
    print(n*100**d)

Solution (Python):



D, N = map(int, input().split())
if N != 100:
    print(pow(100, D) * N)
else:
    print(pow(100, D) * (N + 1))

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

Solution (Python):
import sys
a,b = map(int,input().split())

if a == 0 and b == 100:
  print(101)
  sys.exit()
if a == 0:
  print(b)
if a == 1 and b == 100:
  print(10100)
  sys.exit()
if a == 1:
  print(100 * b)
if a == 2 and b == 100:
  print(1010000)
  sys.exit()
if a == 2:
  print(10000 * b)

Solution (Python):
d, n = map(int, input().split())
ans = n * (100 ** (d))
if (ans // (100 ** d)) % 100 == 0:
    ans = (n + 1) * (100 ** (d))
print(ans)

Solution (Python):
d, n = map(int,input().split(" "))
 
if n == 100:
  print(101*100**d)	
else:
  print(n*100**d)

Solution (Python):
D, N = map(int, input().split())

if N == 100:
    N = 101
print(100 ** D * N)

Solution (Python):
d, n = map(int, input().split())
if n == 100:
    n += 1
print(100 ** d * n)

Solution (Python):
d,n = map(int,input().split())
if d==0:
    if n==100:
        print(101)
    else:
        print(n)
elif d==1:
    if n==100:
        print(100*101)
    else:
        print(100*n)
else:
    if n==100:
        print(10000*101)
    else:
        print(10000*n)

Solution (Python):
d,n = map(int,input().split())

if n == 100:
    a = 101
else:
    a = n

m = 100 ** d
print(a * m)

Solution (Python):
d,n=map(int,input().split())
if n != 100:
    print(n*(100**d))
else:
    print(101*(100**d))

Solution (Python):
d,n=map(int,input().split())
if n!=100:
    print((100**d)*n)
else:
    print((100**d)*(n+1))

Solution (Python):
D, N = map(int, input().split())
if N == 100:
  print(100**D*101)
else:
  print(100**D*N)

Solution (Python):



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

if N == 100:
    print(100**D*N+100**D)
else:
    print(100**D*N)

Solution (Python):
D,N = map(int,input().split())
cnt = 0

calc = 100**D
ans = 0
while cnt != N :
    ans += calc
    
    if (ans % 100**D == 0) and (ans % 100**(D+1) != 0) :
        cnt += 1

print(ans)

Solution (Python):
D,N=map(int, input().split())
if N==100:
    print(101*100**D)
else:
    print(N*100**D)

Solution (Python):
D,N=map(int, input().split())
if N == 100:
    print(100**D*101)
else:
    print(100**D*N)

Solution (Python):
x, y=map(int, input().split())

res=100**x*y

if y==100:
	res=100**x*(y+1)

print(res)

Solution (Python):
D,N = map(int,input().split())
if N != 100:
    print(N*100**D)
else:
    print(101*100**D)

Solution (Python):
D, N = map(int, input().split())
list = [(100 ** D) * (i+i//100) for i in range(1, N + 1)]
print(list[-1])

Solution (Python):
d, n = map(int, input().split())
print(100 ** d * (n + n//100))

Solution (Python):
a, b = map(int, input().split())
if b == 100:
    b += 1
elif b == 200:
    b += 2

print(100 ** a * b)

Solution (Python):

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

if N == 100:
    N = 101

print ((100 ** D) * N )

Solution (Python):
D,N = map(int, input().split())
if N == 100:
    print(101 * 100 ** D)
else:
    print(N * 100 ** D)

Solution (Python):
d, n = map(int, input().split())
if n <= 99:
  ans = 100 ** d * n
else:
  ans = 100 ** d * (n+1)

print(ans)

Solution (Python):
n = [int(i) for i in input().split()]
if n[1] == 100 and n[0] == 0:
    print(101)
elif n[1] == 100 and n[0] == 1:
    print(10100)
elif n[1] == 100 and n[0] == 2:
    print(1010000)
elif n[0] == 0:
    print(n[1])

elif n[0] == 1:
    print(100*n[1])
elif n[0] == 2:
    print(10000*n[1])

Solution (Python):
n = [int(i) for i in input().split()]
if n[1] == 100 and n[0] == 0:
    print(101)
elif n[1] == 100 and n[0] == 1:
    print(10100)
elif n[1] == 100 and n[0] == 2:
    print(1010000)
elif n[0] == 0:
    print(n[1])

elif n[0] == 1:
    print(100*n[1])
elif n[0] == 2:
    print(10000*n[1])

Solution (Python):
n = [int(i) for i in input().split()]
if n[1] == 100 and n[0] == 0:
    print(101)
elif n[1] == 100 and n[0] == 1:
    print(10100)
elif n[1] == 100 and n[0] == 2:
    print(1010000)
elif n[0] == 0:
    print(n[1])

elif n[0] == 1:
    print(100*n[1])
elif n[0] == 2:
    print(10000*n[1])

Solution (Python):
a, b = map(int,input().split())
if a == 0 and b == 100:
  print(101)
elif a == 1 and b == 100:
  print(10100)
elif a == 2 and b == 100:
  print(1010000)
else:
  print((100**a)*b)

Solution (Python):
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)

Solution (Python):
d,n=input().split()
c=int(d)
print(n+'00'*c) if n!='100' else print('101'+'00'*c)

Solution (Python):
def abc():
    d, n = map(int, input().split())

    r = 100 ** d
    if n == 100:
        n += 1
    print(r * n)


abc()

Solution (Python):
d, n = map(int, input().split())
if n == 100: n += 1

if d == 0:
    print(n)
elif d == 1:
    print(n*100)
elif d == 2:
    print(n*10000)

Solution (Python):

import sys


def solve(D: int, N: int):
    if N == 100:
        print((100**D)*101)
    else:
        print((100**D)*N)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    D = int(next(tokens))  
    N = int(next(tokens))  
    solve(D, N)

if __name__ == '__main__':
    main()

Solution (Python):
def resolve():
	d,n=map(int,input().split())
	ans=100**d*n if n<100 else 100**d*101
	print(ans)
resolve()

Solution (Python):

import re
import bisect
from datetime import datetime as dt
import bisect
import math
import sys
input = sys.stdin.readline

def gcd(a, b):
    return math.gcd(a, b)

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

class slist(list):
    def __init__(self, *args, **kw):
        list.__init__(self, *args, **kw)
        self.sort()

    def append(self, value):
        bisect.insort(self,value)

    def index_left(self, value):
        return bisect.bisect_left(self, value)


if __name__ == '__main__':
    d, n = map(int, input().split())
    if n == 100:
        print(100 ** d * (n+1)) 
    else:
        print(100 ** d * n)

Solution (Python):
D,N=map(int,input().split())
if N!=100:
  print(N*100**D)
else:
  print(101*100**D)

Solution (Python):
D,N=map(int,input().split());print((N+N//100)*100**D)

Solution (Python):
D, N = map(int, input().split())
print(100**D * N + (N // 100) * (100 ** D))

Solution (Python):
d,n=map(int, input().split())
if n!=100:
    print(10**(d*2)*n)
else:
    print(10**(d*2)*101)

Solution (Python):
import bisect
import os
from collections import Counter, deque
from fractions import gcd
from functools import lru_cache
from functools import reduce
import functools
import heapq
import itertools
import math
import numpy as np
import re
import sys

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")

D, N = list(map(int, sys.stdin.readline().split()))

if N == 100:
    N += 1
print(100 ** D * N)

Solution (Python):
d, n = map(int, input().split())

if n < 100:
    print(n * pow(100, d))
else:
    print(101 * pow(100, d))

Solution (Python):
D,N = map(int,input().split())
K = (100**D)*N
if N%100 == 0:
  K = (100**D)*(N+1)
print(K)

Solution (Python):
D, N = map(int, input().split())
if N < 100:
    print((100 ** D) * N)
else:
    print((100 ** D) * (N+1))

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

Solution (Python):
D, N = map(int, input().split())
if D == 0:
    if N != 100:
        print(N)
    else:
        print(101)
elif D == 1:
    if N != 100:
        print(100*N)
    else:
        print(10100)
else:
    if N != 100:
        print(10000*N)
    else:
        print(1010000)

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

Solution (Python):
D, N = map(int, input().split())
p = pow(100, D)
if N==100: N=101
print(p*N)

Solution (Python):
D, N = [int(dn) for dn in input().split()]
if N == 100:
  N = 101
ans = (100**D) * N
print(ans)

Solution (Python):
D, N = list(map(int, input().split()))

ans = 0
if N < 100:
    ans = 100**D * N
else: 
    ans = 100**D * (N+1)
print(ans)

Solution (Python):
D, N = map(int, input().split())
if(N == 100):
    print(101*100**D)
else:
    print(N*100**D)

Solution (Python):
D, N = map(int, input().split())
if N == 100:
    print(100**D * 101)
else:
    print((100 ** D) * N)

Solution (Python):
dn = input().split()
d = int(dn[0])
n = int(dn[1])
if n == 100:
  if d == 0:
    a = 101
  elif d == 1:
    a = 10100
  elif d == 2:
    a = 1010000
else:
  if d == 0:
  	a = n
  elif d == 1:
    a = n * 100
  elif d == 2:
    a = n * 10000
print(a)

Solution (Python):
d, n = map(int, input().split())

if d == 0:
    if n == 100:
        print(101)
    else:
        print(n)
elif d == 1:
    if n == 100:
        print(100*101)
    else:
        print(100*n)
else:
    if n == 100:
        print(10000*101)
    else:
        print(10000*n)

Solution (Python):
D, N = map(int, input().split())

if N == 100:
    N += 1

if D == 0:
    print(N)
elif D == 1:
    print(N*100)
else:
    print(N*10000)

Solution (Python):
D, N = map(int, input().split())

if D == 0:
  i = 1
elif D == 1:
  i = 100
else:
  i = 10000

if N == 100:
  print(N * i + i)
else:
  print(N * i)

Solution (Python):
inp = input().split()
d = int(inp[0])
n = int(inp[1])

if n == 100:
    print(100**d * (n+1) )
else:
    print(100**d * n)

Solution (Python):
inp = input().split()
d = int(inp[0])
n = int(inp[1])

if n == 100:
    print(100**d * (n+1) )
else:
    print(100**d * n)

Solution (Python):
d, n = map(int, input().split())

if n != 100:
    if d == 0:
        print(n)
    elif d == 1:
        print(n * 100)
    else :
        print(n * 10000)
else:
    if d == 0:
        print(101)
    elif d == 1:
        print(10100)
    else :
        print(1010000)

Solution (Python):
d,n = map(int,input().split())

if d is 0:
    print(n + n//100)
if d is 1:
    if n is 100:
        print(100*100+100)
    else:
        print(n*100)
if d is 2:
    if n is 100:
        print(100*10000+10000)
    else:
        print(n*10000)

Solution (Python):

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

a = pow(100, d)
if n == 100:
    print(a*(n+1))
else:
    print(a*n)

Solution (Python):
D, N = map(int, input().split())

if N < 100:
    print(100**D * N)
else:
    print(100**D * 101)

Solution (Python):
D,N = map(int,input().split())

if N < 100:
    print(N * (100**D))
else:
    print((N+1) * (100**D))

Solution (Python):
d,n = map(int, input().split())

print(n*100**d if n < 100 else 101*100**d)

Solution (Python):
d,n=map(int,input().split())
print(100**d*n if n<100 else 100**d*101)

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

Solution (Python):
d,n = map(int,input().split())
if n !=100:
    print(n*(100**d))
else:
    print((n+1)*(100**d))

Solution (Python):

import sys
import copy
import collections
from bisect import bisect_left
from bisect import bisect_right
from collections import defaultdict
from heapq import heappop, heappush
import numpy as np
import statistics
from statistics import mean, median,variance,stdev
import math

def main():
	D, N = map(int, input().split(" "))
	
	tmp = str(N)
	if D == 0 and tmp == "100":
		tmp = "101"
	if D == 1:
		if tmp != "100":
			tmp = tmp + "00"
		else:
			tmp = "10100"
	if D == 2:
		if tmp != "100":
			tmp = tmp + "0000"
		else:
			tmp = "1010000"
	
	print(tmp)
	
	
if __name__ == "__main__":
	main()

Solution (Python):
d, n = map(int,input().split())
if n!= 100:
    print(100**d*n)
else:
    print(100**d*101)

Solution (Python):
D,N = map(int,input().split())

if N != 100:
    print(100**D*N)
else:
    print(101*100**D)

Solution (Python):
a,b=map(int,input().split())
if b == 100:
  print(101*(100**a))
else:
  print(b*(100**a))

Solution (Python):
d,n=map(int,input().split())
k=100**d
for i in range(1,n):
    k+=100**d
if n==100:
    k+=100**d
print(k)

Solution (Python):
D,N=map(int,input().split())
if N==100:
  print(100**D*101)
else:
  print(100**D*N)

Solution (Python):
D, N = map(int, input().split())
ans = N * 100**D
if N == 100:
    ans = str(ans)
    print('{}1{}'.format(ans[:2], ans[3:]))
else:
    print(ans)

Solution (Python):
d, n = map(int, input().split())
print(100 ** d * n if n != 100 else 101 * 100 ** d)

Solution (Python):
D, N = map(int, input().split()) 

candidate = []
i = 1
while len(candidate) != 100:
  if i % 100 != 0:
    candidate.append(i)
  i += 1

print(  candidate[N-1] * pow(100, D) )

Solution (Python):
D, N = map(int, input().split())

if N == 100:
    N = 101

print (N * 100 ** D)

Solution (Python):
data = list(map(int,input().split()))
if data[1] == 100:
        print(100**data[0]*101)
else:
        print(100**data[0]*data[1])

Solution (Python):
d,n=map(int,input().split())
if n < 100:
  print(n*(100**d))
else:
  print((n+1)*100**d)

Solution (Python):
a,b=map(int,input().split())
i=0
while b>0:
    i+=1
    if i%(100**a)==0 and i%(100**(a+1))!=0:
        b-=1
    
print(i)

Solution (Python):
D, N = map(int, input().split())

ans = N * (100 ** D)

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

print(ans)

Solution (Python):
d,n=map(int,input().split()) 
if n!=100:
  print(100**d*n)
else:
  print(100**d*(n+1))

Solution (Python):
D, N = map(int, input().split())
if N // 100:
    N += 1
print(100 ** D * N)

Solution (Python):
d, n = map(int, input().split())
if n == 100:
    print((100**d)*(n+1))
else:
    print((100**d)*n)

Solution (Python):
D, N = map(int, input().split())
if N == 100:
  N = N + 1
print(100**D*N)

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

Solution (Python):
d, n = map(int, input().split())

print(100 ** d * (n + (n // 100)))

Solution (Python):
d,n=map(int,input().split())

if d==0 and n!=100:
  print(int(n))
elif d==0 and n==100:
  print(int(101))
  
elif d!=0 and n!=100:
  k=100**d
  print(int(k*n))
else:
  k=100**d
  print(int(k*101))

Solution (Python):

n, k = map(int, input().split())
k = k+1 if k==100 else k
print(100**n*k)

Solution (Python):

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)

Solution (Python):
D, N = map(int, raw_input().split())
ans = ''
if N == 100: ans = '101'
else: ans = str(N)

for i in range(0, D):
	ans = ans + '00'
print ans

Solution (Python):
D,N = map(int,input().split())
if N == 100:
    print(101*(100**D))
else:
    print(N*(100**D))

Solution (Python):
d, n =  [ int(v) for v in input().split() ]
if n != 100:
	print(n*(100**d))
else:
	print(101*(100**d))

Solution (Python):
S = input().split()
D=int(S[0])
N=int(S[1])
Ncnt = N

cnt = 1
ans_list = []
if D == 0:
    cnt = 1
    while True:
        if cnt % 100 == 0:
            cnt += 1
        else:
            ans_list.append(cnt)
            if len(ans_list) == Ncnt:
                break
            else:
                cnt += 1
elif D == 1:
    cnt = 100
    while True:
        if cnt % 10000 == 0:
            cnt += 100
        else:
            ans_list.append(cnt)
            if len(ans_list) == Ncnt:
                break
            else:
                cnt += 100
elif D==2:
    cnt = 10000
    while True:
        if cnt % 1000000 == 0:
            cnt += 10000
        else:
            ans_list.append(cnt)
            if len(ans_list) == Ncnt:
                break
            else:
                cnt += 10000  
else:
    exit()

for ans in ans_list:
    temp_ans = ans

print(temp_ans)

Solution (Python):
d,n=map(int,input().split())
m=n+n//100
print((100**d)*m)

Solution (Python):
d, n = map(int, input().split())
if n == 100:
  output = pow(100, d) * 101
else:
  output = pow(100, d) * n
print(output)

Solution (Python):
[D,N]=list(map(int,input().split()
              )
          )
if N==100:
  print(100**D+100**(D+1))
elif D==0:
  print(N)
else:
  print(N*100**D)

Solution (Python):
D, N = map(int, input().split())
hyaku = N // 100
print(100 ** D * (N+hyaku))

Solution (Python):
D, N = map(int, input().split())
hyaku = N // 100
if D == 1:
  print(100 ** D * (N+hyaku))
elif D == 2:
  print(100 ** D * (N+hyaku))
else:
  print(100 ** D * (N+hyaku))

Solution (Python):
[D,N]=list(map(int,input().split()
              )
          )
if N==100:
  print(100**D+100**(D+1))
elif D==0:
  print(N)
else:
  print(N*100**D)

Solution (Python):
a, b = (int(i) for i in input().split()) 
if b == 100:b+=1
print((100**a)*b)

Solution (Python):
D, n = map(int, input().split())
if n == 100: n += 1
print(n*(100**D))

Solution (Python):

import sys


def solve(D: int, N: int):
    n = N
    if n == 100:
        n = 101
    print(int((100**D)*n))



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    D = int(next(tokens))  
    N = int(next(tokens))  
    solve(D, N)

if __name__ == '__main__':
    main()

Solution (Python):
d, n = map(int, input().split())
if n!=100:
    print((100**d) * n)
else:
    print((100**d) * (n+1))

Solution (Python):
D, N = map(int, input().split())
if N < 100:
    print((100 ** D) * N)
else:
    print((100 ** D) * (N+1))

Solution (Python):
d,n = map(int, input().split())

divide = []

if d == 0:
    for i in range(1, 100):
        divide.append(i)    
    divide.append(101)
elif d == 1:
    for i in range(100, 10000, 100):
        divide.append(i)
    divide.append(10100)
    
else:
    for i in range(10000, 1000000, 10000):
        divide.append(i)
    divide.append(1010000)
print(divide[n - 1])

Solution (Python):
D,N = map(int,input().split())
t = N*(100**D)//100**(D+1)
g = (N+t)*(100**D)
print(g)

Solution (Python):
d,n=map(int,input().split())

if n%100==0:
    print((n+1)*100**d)
else:
    print(n*100**d)

Solution (Python):
D,N = map(int,input().split())
s = []
if N != 100:
    for i in range(1,101):
        s.append(i*(100**D))
    print(s[N-1])
else:
    print((100**D*101))

Solution (Python):
d,n=map(int, input().split())

if n == 100:
    print(100**d*(n+1))
else:
    print(100**d*(n))

Solution (Python):
d,n=map(int, input().split())
print(100**d*(n+1) if n==100 else 100**d*n)

Solution (Python):
d,n=map(int,input().split())
if n==100:
  print((n+1)*(100**d))
else:
  print((n)*(100**d))

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    d,n  = f()
    if n == 100:
        n+= 1
    print(n * 100**d)

solve()

Solution (Python):
D, N = map(int, input().split())
print(100 ** D * N if N != 100 else 100 ** D * 101)

Solution (Python):
d, n = map(int, input().split())
for i in range(3):
    if d == i:
        if n == 100:
            ans = 101*100**d
        else:
            ans = n*100**d
print(ans)

Solution (Python):
D,N=map(int,input().split())
F=100**D
if N<100:
  print(F*N)

else:
  print(F*101)

Solution (Python):
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)
elif D == 2:
    if N == 100:
        print(1010000)
    else:
        print(N * 10000)

Solution (Python):
C, N = map(int, input().split())
hund = N if N != 100 else 101
print((100**C)*hund)

Solution (Python):
a,b=list(map(int,input().split(" ")))
i=0
while b>0:
  i+=1
  if i%(100**a)==0 and i%(100**(a+1))!=0:
    b-=1
print(i)

Solution (Python):
d, n = map(int, input().split())
if n == 100:
    print(n*100**d + 100**d)
else:
    print(n * 100**d)

Solution (Python):

import sys


def solve(D: int, N: int):
    ret = (100 ** D) * N
    if N == 100:
        ret = (100 ** D) * (N + 1)
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    D = int(next(tokens))  
    N = int(next(tokens))  
    solve(D, N)

if __name__ == '__main__':
    main()

Solution (Python):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance





def main():
    d, n = intin()

    if n == 100:
        print(101 * (100**d))
    else:
        print(n * (100**d))


if __name__ == '__main__':
    main()

Solution (Python):
d, n = map(int, input().split())
if n == 100:
    print(n*100**d + 100**d)
else:
    print(n * 100**d)

Solution (Python):
D, N = map(int, input().split())

if N != 100:
    print((100 ** D) * N)
else:
    print((100 ** D) * 101)

Solution (Python):
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)

Solution (Python):
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)

Solution (Python):
A,B = [int(i) for i in input().split()]

if B != 100:
    print(100**A*B)
else:
    print(100**A*(B+1))

Solution (Python):


import sys                                                      
sys.setrecursionlimit(10**6)                                    
from collections import deque, Counter                          
from itertools   import accumulate, permutations, combinations  
from operator    import itemgetter                              
from bisect      import bisect_left, bisect_right, bisect       
from heapq       import heappop, heappush                       
from fractions   import gcd                                     
from math        import ceil, floor, sqrt, cos, sin, tan, pi    
from copy        import deepcopy                                
import numpy         as np                                      


def main():
    
    im = InputManager()
    
    d, n = im.inputMultiple()
    
    message = ""
    if n == 100:
        message += "101"
    else:
        message += str(n)
    for i in range(d):
        message += "00"
    
    print(message)
    
    return


class InputManager(object):
    def __init__(self):
        pass

    @staticmethod
    def inputSingle(dtype=int):
        return dtype(input())
    
    @staticmethod
    def inputMultiple(dtype=int, aslist=False):
        if aslist:
            return list(map(dtype, input().split()))
        else:
            return map(dtype, input().split())

    @staticmethod
    def input2D(h, dtype=int):
        return [list(map(dtype, input().split())) for i in range(h)]


main()

Solution (Python):
d,n = map(int, input().split())
r = 0
if n == 100:
    if d == 0:
        print( 1 * 101)
    elif d == 1:
        print( 100 * 101)
    elif d == 2:
        print( 100*100 * 101)
else:
    if d == 0:
        print(n * 1)
    elif d == 1:
        print(n * 100)
    elif d == 2:
        print(n * 100*100)

Solution (Python):
d,n=map(int,input().split())
if(n<100):
    print(100**d*n)
else:
    print(100**d*101)

Solution (Python):
D, N = map(int, input().split())
print((100 ** D) * N if N != 100 else (100 ** D) * (N + 1))

Solution (Python):
d,n=map(int,input().split())
if n!=100:
    print(n*100**d)
else:
    print(n*100**d+n*100**d//100)

Solution (Python):
D, N = map(int, input().split())
num = 100**D
if num == 1:
    print(N if N != 100 else 101)
else:
    print(num*N if N != 100 else num*(N+1))

Solution (Python):
dn=list(map(int,input().split()))
d=dn[0]
n=dn[1]
if n<100:
    print(n*100**d)
else:
    if d==0:
        print(101)
    elif d==1:
        print(10100)
    else:
        print(1010000)

Solution (Python):


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

ans = (100 ** d) * (n + n // 100)
print(ans)

Solution (Python):
D,N=map(int,input().split())
if N<100:
    print((100**D)*N)
else:
    print((100**D)*101)

Solution (Python):
def B(S):
    D,N = map(int,S.split())
    print(100**D*(N if N!=100 else 101))

B(input())

Solution (Python):
D, N = map(int, input().split())

print(100**D * (N if N != 100 else 101))

Solution (Python):
D, N = map(int, input().split())

n = 0
count = 0
while True:
    n += 100**D
    target = n
    count_div = 0
    while True:
        if target % 100 == 0:
            count_div += 1
            target //= 100
        else:
            break
    if count_div == D:
        count += 1

    if count == N:
        print(n)
        exit()

Solution (Python):
D, N = map(int, input().split())

n = 100**D
count = 0
while True:
    target = n
    count_div = 0
    while True:
        if target % 100 == 0:
            count_div += 1
            target //= 100
        else:
            break
    if count_div == D:
        count += 1

    if count == N:
        print(n)
        exit()

    n += 100**D

Solution (Python):
D, N = map(int, input().split())

if D == 0 and N == 100:
    print(101)
elif D == 1 and N == 100:
    print(10100)
elif D == 2 and N == 100:
    print(1010000)
else:
    print(100**D*N)

Solution (Python):
d,n = map(int,input().split())
if n != 100:    
    print(100**d*n)
else:
    print(100**d*101)

Solution (Python):
from itertools import *
d, n = map(int, input().split())
ite = (x * 100 ** d for x in count() if x % 100 != 0)
print(next(islice(ite, n - 1, None)))

Solution (Python):
from itertools import *
d, n = map(int, input().split())
delta = 100 ** d
ite = (x * delta for x in count() if x % 100 != 0)
print(next(islice(ite, n - 1, None)))

Solution (Python):
from itertools import *
d, n = map(int, input().split())
delta = 100 ** d
ite = (x for x in count(delta, delta) if x % (delta * 100) != 0)
print(next(islice(ite, n - 1, None)))

Solution (Python):
from itertools import *
d, n = map(int, input().split())
delta = 100 ** d
ite = (x for x in count(delta, delta) if x % (delta * 100) != 0)
print(list(islice(ite, n - 1, n))[0])

Solution (Python):
from itertools import *
d, n = map(int, input().split())
delta = 100 ** d
ite = (x for x in count(delta, delta) if x % (delta * 100) != 0)
print(list(islice(ite, n - 1, n))[0])

Solution (Python):
from itertools import *

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

D, N = map(int, input().split())
delta = 100 ** D
ite = (x for x in count(delta, delta) if x % (delta * 100) != 0)
print(nth(ite, N - 1))

Solution (Python):
d,n=map(int,input().split());print([pow(100,d)*n,pow(100,d)*101][n==100])

Solution (Python):


def solve():
    D, N = list(map(int, input().split()))

    if N != 100:
        ans = (100**D)*N
    else:
        ans = (100**D)*101
    
    print(ans)


if __name__ == "__main__":
    solve()

Solution (Python):
d, n = [int(i) for i in input().split()]
if n == 100:
  print((n+1)*(100**d))
else:
  print(n*(100**d))