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):
D, N = map(int, input().split())
print(100 ** D * N if N != 100 else 100 ** D * (N + 1))

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

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:
    ans = 100 ** D * (N+1)
else:
    ans = 100 ** D * N
print(ans)

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 = 101
print(n*(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 if n!=100 else 100**d * 101)

Solution (Python):
d,n=map(int,input().split())
a=[100**d*i for i in range(n+1)]
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(a[-1])

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**6)

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

if d==0:
    if n==100:
        print(n+1)
        exit()
    print(n)
elif d!=0 and n==100:
    print((n+1)*100**d)
else:
    print(n*100**d)

Solution (Python):
D,N = list(map(int,input().split()))
count = 0
now = 1
while True:
    tmp = now*100**D
    if tmp%(100**(D+1)) != 0:
        count += 1
    if count == N:
        print(tmp)
        exit()
    now += 1

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

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] = list(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())

ans=1
for i in range(d):
    ans*=100
ans*=n

if d==0 and n==100:
    ans+=1
if d==1 and n==100:
    ans+=100
if d==2 and n==100:
    ans+=10000

print(ans)

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

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

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

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

d = 100 ** D

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

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

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

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

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

Solution (Python):
d,n = list(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):
d,n = map(int, input().split())
if n == 100:
    n += 1
print(n if d==0 else 100*n if d==1 else pow(100,2)*n)

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

Solution (Python):
def calc(n):
	if n % 100 != 0:
		return 0
	return calc(n/100) + 1

def resolve():
	d, n = map(int, input().split())
	n = n + calc(n)
	print(100**d*n)
resolve()

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

if n == 100:
    n += 1

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

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

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

Solution (Python):






import sys
input = sys.stdin.readline

import math

import bisect
from collections import defaultdict
from collections import deque
from functools import lru_cache






MOD = 10**9+7
INF = float('inf')






def inputI(): return int(input().strip())
def inputS(): return input().strip()
def inputIL(): return list(map(int,input().split()))
def inputSL(): return list(map(str,input().split()))
def inputILs(n): return list(int(input()) for _ in range(n))
def inputSLs(n): return list(input().strip() for _ in range(n))
def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]


def Yes(): print("Yes"); return
def No(): print("No"); return


def inv(n): return pow(n, MOD-2, MOD)


kaijo_memo = []
def kaijo(n):
  if(len(kaijo_memo) > n):
    return kaijo_memo[n]
  if(len(kaijo_memo) == 0):
    kaijo_memo.append(1)
  while(len(kaijo_memo) <= n):
    kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
  return kaijo_memo[n]

gyaku_kaijo_memo = []
def gyaku_kaijo(n):
  if(len(gyaku_kaijo_memo) > n):
    return gyaku_kaijo_memo[n]
  if(len(gyaku_kaijo_memo) == 0):
    gyaku_kaijo_memo.append(1)
  while(len(gyaku_kaijo_memo) <= n):
    gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
  return gyaku_kaijo_memo[n]

def nCr(n,r):
  if(n == r):
    return 1
  if(n < r or r < 0):
    return 0
  ret = 1
  ret = ret * kaijo(n) % MOD
  ret = ret * gyaku_kaijo(r) % MOD
  ret = ret * gyaku_kaijo(n-r) % MOD
  return ret


def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])
    return arr


def make_divisors(n):
  divisors = []
  for i in range(1, int(n**0.5)+1):
    if n % i == 0:
      divisors.append(i)
      if i != n // i: 
        divisors.append(n//i)
  return divisors


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


def count_bit(n):
  count = 0
  while n:
    n &= n -1
    count += 1
  return count


def Base_10_to_n(X, n):
  if (int(X/n)):
    return Base_10_to_n(int(X/n), n)+[X%n]
  return [X%n]






D,N = inputIL()

if N != 100:
  print(str(N)+"00"*D)
else:
  print(str(101)+"00"*D)

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(100*101)
elif d==2:
    if n!=100:
        print(10000*n)
    else:
        print(10000*101)

Solution (Python):
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import permutations, accumulate, combinations, combinations_with_replacement
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
from fractions import gcd
import sys
def input(): return sys.stdin.readline().rstrip()
def I(): return int(input())
def Is(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def TI(): return tuple(map(int, input().split()))
def IR(n): return [I() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def TIR(n): return [TI() for _ in range(n)]
def S(): return input()
def Ss(): return input().split()
def LS(): return list(input())
def SR(n): return [S() for _ in range(n)]
def SsR(n): return [Ss() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
sys.setrecursionlimit(10**6)
MOD = 10**9+7
INF = 10**18


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

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

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

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

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

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

Solution (Python):
import numpy as np
D, N = map(int, input().split())

def cnt(n):
    tmp = 0
    n = n*1.0
    while n.is_integer():
        if (n/100.0).is_integer():
            tmp += 1
            n = n / 100.0
        else:
            break
            
    return tmp

coef = 100**D
whole = np.array([i*coef for i in range(1, 150)])
result = np.array(list(map(cnt, whole)))

print(whole[np.where(result==D)][N-1])

Solution (Python):
d, n = [int(x) for x in input().split()]
gap = 100 ** d
gap_check = gap * 100
count = 0
ans = 0
while True:
    ans += gap
    if ans % gap_check != 0:
        count += 1
        if count >= n:
            break
print(ans)

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

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(101)
    else:
        print(n)
else:
    if(n==100):
        print(100**d*101)
    else:
        print(100**d*n)

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

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

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

Solution (Python):
def calc(x):
    ret = 0
    while x % 100 ==0:
        x /= 100
        ret += 1
    return ret

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

cnt = 0
val = 0

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

print(val)

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

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

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

Solution (Python):


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

Solution (Python):
import math

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

if N == 100:
    N = 101

print(int(math.pow(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=list(map(int,input().split()))
ans="0"*(D*2)
if N == 100:
   N=101
print(int(str(N)+ans))

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

Solution (Python):
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 = 100 * n
elif d == 2:
    if n == 100:
        ans = 1010000
    else:    
        ans = 10000 * n

print(ans)

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

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

Solution (Python):


import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))

from itertools import accumulate
def resolve():
    D,N=pin()
    if D==0:
        if N!=100:print(N)
        else:print(101)
    if D==1:
        if N!=100:print(N*100)
        else:print(10100)
    if D==2:
        if N!=100:print(N*10000)
        else:print(1010000)

resolve()

Solution (Python):
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
D,N = LI()
sequence = []
for i in range(1,N+1):
    sequence.append(i*100**D)
ans = sequence[-1]

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

Solution (Python):
a=input().split(" ")
d=100**int(a[0])
k=int(a[1])
ans=d*k
if k==100:
  ans=ans+d
print(ans)

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().strip().split())


def judge(num):
    count = 0
    while True:
        if count == d:
            return num % 100 != 0

        if num % 100 == 0:
            count += 1
            num //= 100
        else:
            return False


found = 0
num = 1
while True:
    if judge(num):
        found += 1

    if found == n:
        print(num)
        break

    num += 1

Solution (Python):
import sys
input = sys.stdin.readline

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


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

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

Solution (Python):
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
D, N = M()
i = 100**D
if N < 100:
    print(N*i)
else:
    print(101*i)

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(100**d*101)
else:
    print(str(n)+'00'*d)

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())
count =0
number = 0
list=[]
while count < 100:
    number+= 1
    if number % 100 != 0:
        count += 1
        list.append(number)

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

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:
  N = 101

print(100**D*N)

Solution (Python):
D,N=map(int, input().split())
print((N+int(N/100))*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())
a = 100**d
if n != 100:
  print(a*n)
else:
  print(a*101)

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

Solution (Python):

import sys
import math
from bisect import bisect_left, bisect_right, insort_left, insort_right
from collections import defaultdict, deque, Counter
from copy import deepcopy
from fractions import gcd
from functools import lru_cache, reduce
from heapq import heappop, heappush
from itertools import accumulate, groupby, product, permutations, combinations, combinations_with_replacement
from math import ceil, floor, factorial, log, sqrt, sin, cos
from operator import itemgetter
from string import ascii_lowercase, ascii_uppercase, digits
sys.setrecursionlimit(10**7)
rs = lambda: sys.stdin.readline().rstrip()
ri = lambda: int(rs())
rf = lambda: float(rs())
rs_ = lambda: [_ for _ in rs().split()]
ri_ = lambda: [int(_) for _ in rs().split()]
rf_ = lambda: [float(_) for _ in rs().split()]
INF = float('inf')
MOD = 10 ** 9 + 7
PI = math.pi

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

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

Solution (Python):

def main():
    d, n = map(int, input().split())
    dd = 100**d
    if n%100 != 0:
        ans = n*dd
    else:
        ans = (1+n)*dd
    print(ans)
main()

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

Solution (Python):
from math import pow
d,n = map(int,input().split())
ans = pow(100,d)*n
if n==100:
	ans += pow(100,d)
print (int(ans))

Solution (Python):
d,n=input().split()
if n=="100":
    n="101"
d=int(d)
for i in range(d):
    n+="00"
print(n)

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

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


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

print(ans)

Solution (Python):
d, n=map(int, input().split())
k=100**d
cnt=0
i=0
while cnt!=n:
    i+=1
    if i%100!=0:
        cnt+=1

print(k*i)

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

if n==100:
    num="101"+2*d*"0"
    num=int(num)
    print(num)
else:
    print(k*n)

Solution (Python):

list = [int(i) for i in input().split(" ")]
fillzero = 0
plus = 0
if list[0] == 0:
    fillzero = 1
    plus = 1
elif list[0] == 1:
    fillzero = 100
    plus = 100
elif list[0] == 2:
    fillzero = 10000
    plus = 10000
if list[1] != 100:
    print(list[1] * fillzero)
else:
    print((list[1] * fillzero)+plus)

Solution (Python):
D_kai, N_ban = map(int, input().split())

begin = 100 ** D_kai

if (N_ban == 100):
    ans = begin * 101
else:
    ans = begin * N_ban

print(ans)

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 = 101
if d == 0:
  print(n)
elif d == 1:
  print(str(n) + '00')
else:
  print(str(n) + '0000')

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):
D, N = map(int, input().split())

count = 1
num = 100 ** D
while count != N:
    num += 100 ** D
    if num % (100 ** (D + 1)) == 0:
        continue
    else:
        count += 1

print(num)

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(101*100)
else:
  if n != 100:
    print(10000*n)
  else:
    print(101*10000)

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

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

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(100**d*n if n<100 else 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())
skips = N // 100
print((100 ** D) * (N+skips))

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


def main():
    D, N = map(int, open(0).read().split())
    if N == 100:
        print(101*100**D)
    else:
        print(N*100**D)


main()

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

Solution (Python):
D, N = map(int, input().split())
li = []
cnt = 1
while len(li) < N:
    if cnt % 100 != 0:
        li.append(cnt * 100 ** D)
    cnt += 1

print(li[-1])

Solution (Python):
d, n = map(int, input().split())
print([i*100**d for i in range(1, 102) if i != 100][n - 1])

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

Solution (Python):


def main():
    d, n = map(int, input().split())
    dd = 100**d
    if n%100 != 0:
        ans = n*dd
    else:
        ans = (1+n)*dd
    print(ans)
main()

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 d==0 and n==100:
    print(101)
elif d==1 and n==100:
    print(10100)
elif d==2 and n==100 :
    print(1010000)
else:
    base = 100**d
    print(base*n)

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

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

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

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 = 0
if n != 100:
  ans = 100**d * n
else:
  ans = 100**d * 101
print(ans)

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

Solution (Python):


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

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

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

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

print(ans)

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

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())
list = []
i = 1

while len(list) < N:
  if D != 0:
    if i != 100:
      list.append(i * 100 ** D)
      i += 1
    else:
      i += 1
   
  else:
    if i != 100:
      list.append(i)
      i += 1
    else:
      i += 1
    
print(list[-1])

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

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

Solution (Python):

import re
import math
from collections import defaultdict
import itertools
from copy import deepcopy
import random
from heapq import heappop,heappush
import time
import os
import queue
import sys
import datetime
from functools import lru_cache
readline=sys.stdin.readline
sys.setrecursionlimit(2000)

alphabet="abcdefghijklmnopqrstuvwxyz"
mod=int(10**9+7)
inf=int(10**20)
def yn(b):
    if b:
        print("yes")
    else:
        print("no")
def Yn(b):
    if b:
        print("Yes")
    else:
        print("No")
def YN(b):
    if b:
        print("YES")
    else:
        print("NO")
class union_find():
    def __init__(self,n):
        self.n=n
        self.P=[a for a in range(N)]
        self.rank=[0]*n
 
    def find(self,x):
        if(x!=self.P[x]):self.P[x]=self.find(self.P[x])
        return self.P[x]
 
    def same(self,x,y):
        return self.find(x)==self.find(y)
 
    def link(self,x,y):
        if self.rank[x]<self.rank[y]:
            self.P[x]=y
        elif self.rank[y]<self.rank[x]:
            self.P[y]=x
        else:
            self.P[x]=y
            self.rank[y]+=1
 
    def unite(self,x,y):
        self.link(self.find(x),self.find(y))
 
    def size(self):
        S=set()
        for a in range(self.n):
            S.add(self.find(a))
        return len(S)
def is_power(a,b):
    now=b
    while now<a:
        now*=b
    if now==a:return True
    else:return False
def bin_(num,size):
    A=[0]*size
    for a in range(size):
        if (num>>(size-a-1))&1==1:
            A[a]=1
        else:
            A[a]=0
    return A
def get_facs(n,mod_=0):
    A=[1]*(n+1)
    for a in range(2,len(A)):
        A[a]=A[a-1]*a
        if(mod>0):A[a]%=mod_
    return A
def comb(n,r,mod,fac):
    if(n-r<0):return 0
    return (fac[n]*pow(fac[n-r],mod-2,mod)*pow(fac[r],mod-2,mod))%mod
def next_comb(num,size):
    x=num&(-num)
    y=num+x
    z=num&(~y)
    z//=x
    z=z>>1
    num=(y|z)
    if(num>=(1<<size)):return False
    else:
        return num
def get_primes(n,type="int"):
    A=[True]*(n+1)
    A[0]=False
    A[1]=False
    for a in range(2,n+1):
        if A[a]:
            for b in range(a*2,n+1,a):
                A[b]=False
    if(type=="bool"):return A
    B=[]
    for a in range(n+1):
        if(A[a]):B.append(a)
    return B
def is_prime(num):
    if(num<=2):return False
    i=2
    while i*i<=num:
       if(num%i==0):return False
       i+=1
    return True
def ifelse(a,b,c):
    if a:return b
    else:return  c
def join(A,c=" "):
    n=len(A)
    A=list(map(str,A))
    s=""
    for a in range(n):
        s+=A[a]
        if(a<n-1):s+=c
    return s
def factorize(n,type_="dict"):
    b = 2
    list_ = []
    while b * b <= n:
        while n % b == 0:
            n //= b
            list_.append(b)
        b+=1
    if n > 1:list_.append(n)
    if type_=="dict":
        dic={}
        for a in list_:
            if a in dic:
                dic[a]+=1
            else:
                dic[a]=1
        return dic
    elif type_=="list":
        return list_
    else:
        return None
def floor_(n,x=1):
    return x*(n//x)
def ceil_(n,x=1):
    return x*((n+x-1)//x)
def hani(x,min_,max_):
    ret=x
    if x<min_:ret=min_
    if x>max_:ret=max_
    return ret
def seifu(x):
    return x//abs(x)


def main():
    D,N=map(int,input().split())
    num=100**D
    A=[]
    for a in range(1,1010001):
        cnt=0
        now=a
        while now%100==0:
            now//=100
            cnt+=1
        if cnt==D:
            A.append(a)
    print(A[N-1])
main()

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

Solution (Python):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections

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 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):
d,n = map(int, input().split())
n += n // 100
print(str(n) + "00"*d)

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())
print(100**d*n if n!=100 else 100**d*(n+1))

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

if d==0:
  cnt=0
  i=1
  while 1:
    if i%100!=0:
      cnt+=1
    if cnt==n:
      print(i)
      exit()
    i+=1
else:
  cnt=0
  i=1
  waru=100**d
  while 1:
    if i%waru==0 and (i//waru)%100 !=0 :
      cnt+=1
    if cnt==n:
      print(i)
      exit()
    i+=1

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    D, N = [int(x) for x in input().split()]
    if N == 100:
        N += 1
    ans = 100 ** D * N
    print(ans)


if __name__ == '__main__':
    main()

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

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

ans = (100**d)*n
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 * 101)

Solution (Python):
d, n = map(int, input().split())
def division(x):
    if x % 100 != 0:
        return 0
    else:
        return division(x//100) +1
count= 0
for i in range(1, 1010001):
    if division(i) == d:
        count +=1
    if count == n:
        print(i)
        break

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

d = 100 ** D * N

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

print(d)

Solution (Python):
d,n=map(int,input().split())
s=list(range(0,102))
s.pop(-2)
print(s[n]*(100**d))