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):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

D, N = MAP()
i = 0

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

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

if n == 100:
    n = 101

ans = 100**d*n

print(ans)

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

if d > 0:
    ans = 100**d*n
    if n == 100:
        ans = 100**d*101
else:
    ans = n
    if n == 100:
        ans = 101

print(ans)

Solution (Python):
d, n = [int(x) for x in input().split()]

x = 100 ** d

if n == 100:
    n = 101

ans = n * x
print(ans)

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


if __name__ == '__main__':
    main()

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

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

Solution (Python):
def myAnswer(D:int, N:int) -> int:
   if(D == 0):
      return 101 if(N == 100) else N
   elif(D == 1):
      return 10100 if(N == 100) else N*100
   else:
      return 1010000 if(N == 100) else N*10000
         



def modelAnswer():
   tmp=1
def main():
   D,N =map(int,input().split())
   print(myAnswer(D,N))
if __name__ == '__main__':
   main()

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

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

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

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

Solution (Python):
import sys

s = input().split(' ')
d, n = int(s[0]), int(s[1])

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

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

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

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

    c = pow(100, D)

    x = 1
    cnt = 0
    while True:
        if x % 100 != 0:
            cnt += 1
            if cnt == N:
                break
        x += 1
    print(x * c)


if __name__ == '__main__':
    main()

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

x = 1
while n>0:
    if x%d==0 and (x//d)%100>0:
        n -= 1
    x += 1
print(x-1)

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

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


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

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

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

if n == 100:
    n += 1

print(n*100**d)

Solution (Python):
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions,pprint
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))

d,n = inpl()
res = n*100**(d)
if n == 100:
    res += 100**(d)
print(res)

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

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

Solution (Python):



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


ans = 0
tmp = 100**D


i = 1
while i<=N:
    if i==100:
        ans = tmp * (i + 1)
        break
    ans = tmp * i
    i += 1


print(ans)

Solution (Python):
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 heapq import heapify, heappop, heappush

def input(): return sys.stdin.readline().strip()
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 = float('inf')
mod = 10 ** 9 + 7

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

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())
a=[]
for i in range(1,102):
  if i==100:continue
  t=100**d
  a.append(i*t)
print(a[n-1])

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

Solution (Python):
from heapq import heappush, heappop
from itertools import permutations, accumulate, combinations
import math
import bisect
import numpy as np
from collections import defaultdict, deque
from operator import itemgetter
import sys
input = sys.stdin.readline





def main():
    d, n = map(int, input().split())
    if d == 0:
        ans = n
        if n == 100:
            ans += 1
    else:
        ans = 100 ** d * n
        if d == 1 and n == 100:
            ans += 100
        elif d == 2 and n == 100:
            ans += 10000
    print(ans)


if __name__ == '__main__':
    main()

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

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

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

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

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

  if d == 2:
    if n == 100:
      print(1010000)
    else:
      print(10000 * n)
    return

  return

if __name__ == "__main__":
  resolve()

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

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

Solution (Python):
def main():
    D, N = (int(i) for i in input().split())
    if N == 100:
        N += 1
    print(N*100**D)


if __name__ == '__main__':
    main()

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
sys.setrecursionlimit(1 << 25)
read = sys.stdin.readline
ra = range
enu = enumerate


def read_ints():
    return list(map(int, read().split()))


def read_a_int():
    return int(read())


def read_tuple(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(tuple(map(int, read().split())))
    return ret


def read_col(H):
    '''
    H is number of rows
    A列、B列が与えられるようなとき
    ex1)A,B=read_col(H)    ex2) A,=read_col(H) 
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return tuple(map(list, zip(*ret)))


def read_matrix(H):
    '''
    H is number of rows
    '''
    ret = []
    for _ in range(H):
        ret.append(list(map(int, read().split())))
    return ret
    


MOD = 10**9 + 7
INF = 2**31  

from collections import defaultdict, Counter, deque
from operator import itemgetter
from itertools import product, permutations, combinations
from bisect import bisect_left, bisect_right  



D, N = read_ints()
if N == 100:
    N += 1
print(N * (100**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(n*100)
    else:
        print(n*101)
else:
    if n != 100:
        print(n*10000)
    else:
        print(n*10100)

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

cnt = 0
for n in range(1, 10 ** 7):
    can, tmp = 0, n
    while tmp % 100 == 0:
        tmp //= 100
        can += 1
    
    if can == D:
        cnt += 1
    
    if cnt == N:
        print(n)
        exit()

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

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

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

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

if D == 0:
    c = N//100
    print(N+c)
else:
    tmp = 100 ** D
    c = N//100
    print(tmp*N+c*tmp)

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 D == 0:
    print(N if N != 100 else 101)
elif D == 1:
    print(N*100 if N != 100 else 101 * 100)
elif D == 2:
    print(N*10000 if N != 100 else 101 * 10000)

Solution (Python):
def myAnswer(D:int, N:int) -> int:
   if(N == 100):
      return 100**D * (N + 1 )
   else:
      return 100**D * N


def modelAnswer():
   tmp=1
def main():
   D,N =map(int,input().split())
   print(myAnswer(D,N))
if __name__ == '__main__':
   main()

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

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

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())
base=10**(2*D)
if N!=100:
  print(N*base)
else:
  print((N+1)*base)

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

cnt = 0
for n in range(1, 10 ** 7):
    can, tmp = 0, n
    while tmp % 100 == 0:
        tmp //= 100
        can += 1
    
    if can == D:
        cnt += 1
    
    if cnt == N:
        print(n)
        exit()

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

ans = pow(100, D) * N

if N == 100:
    ans += pow(100, D)

print(ans)

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

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

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

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.buffer.readline().split()]
def I(): return int(sys.stdin.buffer.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    d,n = LI()
    if n == 100:
        print((n+1)*100**d)
    else:
        print(n*100**d)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
def main():
    D, N = (int(i) for i in input().split())
    if N == 100:
        N += 1
    print(N*100**D)


if __name__ == '__main__':
    main()

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(N*100)
    else:
        print(10100)
else:
    if N < 100:
        print(N*10000)
    else:
        print(1010000)

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

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

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

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

D, N = MAP()

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

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

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

if N <= 99:
    print(N, end = "")
    for _ in range(D):
        print("00", end = "")
    print("")
else:
    if D == 0:
        print(101)
    elif D == 1:
        print(10100)
    else:
        print(1010000)

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

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

base = 100 ** D
cnt = 0
i = 1
while True:
    if i % 100 != 0:
        cnt += 1
    
    if cnt == N: break
    i += 1

ans = i * base

print(ans)

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

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

Solution (Python):
icase=100
if icase==100:    
    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().rstrip().split(' '))
if n!=100:
	print(n*(100**d))
else:
  	print((n+1)*(100**d))

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

Solution (Python):

import sys

def main():
    D, N = map(int, input().split())
    l = []
    for i in range(1,10000*120):
        if i % (100**D) == 0 and i % (100**(D+1)) != 0:
            l.append(i)
    
    print(l[N-1])

if __name__ == '__main__':
    main()

Solution (Python):

import sys

def main():
    D, N = map(int, input().split())
    if N != 100:
        print((100**D)*N)
    else:
        print((100**D)*101)
    return

if __name__ == '__main__':
    main()

Solution (Python):
D,N=map(int,input().split());print(100**D*[N,101][N>99])

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

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

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

Solution (Python):

import io

nim,mike=map(int,input().split())
if mike!=100:
    print(mike*(100**nim))
else:
    print(101*(100**nim))

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

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

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

Solution (Python):
import math, sys
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict, deque
from copy import deepcopy
from functools import lru_cache
from heapq import heapify, heappop, heappush
from itertools import accumulate, combinations, permutations
input = sys.stdin.readline
mod = 10**9 + 7
ns = lambda: input().strip()
ni = lambda: int(input().strip())
nm = lambda: map(int, input().split())
nl = lambda: list(map(int, input().split()))

d, n = nm()

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

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

Solution (Python):

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

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

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

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

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

cnt = 0
for num in range(1, 10 ** 8):
    if num % 100 ** D == 0 and num % 100 ** (D+1) != 0:
        cnt += 1
        if cnt == N:
            print(num)
            break

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

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

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

if x == 0:
    if y == 100:
        print(101)
    else:
        print(y)
if x == 1:
    if y == 100:
        print(10100)
    else:
        print(y*100)
if x == 2:
    if y == 100:
        print(1010000)
    else:
        print(y*10000)

Solution (Python):
D,N = map(int,input().split())
res = 0
num = 0
while True:
  res += 1
  x = res
  count = 0
  while x >= 100:
    d = x % 100
    if d != 0: break
    x //= 100
    count += 1
  if count == D:
    num += 1
  if num == N:
    break
print(res)

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

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

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

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

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

d,n = iim()
num = 0
for i in range(n):
    num += 100**d
    if num%100**(d+1) == 0:
        num += 100**d
print(num)

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

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

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

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

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

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

Solution (Python):
p,q= input().split()
a,b =(int(p), int(q))
ans =100**a

if b==100:
    print(101*ans)
else:
    print(ans*b)

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

Solution (Python):
a=list(map(int,input().split()))
if a[0]==0 and a[1]!=100:
    print(a[1])
elif a[0]==0 and a[1]==100:
    print(101)
elif a[0]==1 and a[1]!=100:
    print(str(a[1])+"00")
elif a[0]==1 and a[1]==100:
    print(10100)
elif a[0]==2 and a[1]!=100:
    print(str(a[1])+"0000")
elif a[0]==2 and a[1]==100:
    print(1010000)

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

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

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

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

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

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

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

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

num_list  = []
for i in range(1,n+1):
    num_list.append(i*(100**d))
    if i == 100:
        i = i+1
        num_list.append(i*(100**d))

print(num_list[-1])

Solution (Python):

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

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

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

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

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

ans = []

cnt=0

if D == 0:
    for i in range(1, 1500000):
        if i%100 != 0:
            cnt += 1
            if cnt == N:
                print(i)
                break
    
else:
    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

Solution (Python):
a=input();print(int(int(a[2:])*1.01)*100**int(a[0]))

Solution (Python):
a=input();print(int(int(a[2:])*1.01)*100**int(a[0]))

Solution (Python):
a=input();print((eval(a[2:])+len(a)//5)*100**int(a[0]))

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

Solution (Python):
a=input();print(int(eval(a[2:])*1.01)*100**int(a[0]))

Solution (Python):
a=input();print(int(eval(a[2:5])*1.01)*100**int(a[0]))

Solution (Python):
a=input();print(int(eval(a[2:5])*1.01)*100**eval(a[0]))

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

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

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

Solution (Python):



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


def main():
    if N == 100:
        ans = 100 ** (D + 1) + 100 ** D
    else:
        ans = str(N) + "00" * D
    print(ans)


if __name__ == "__main__":
    main()

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 d==0:
    ans=1*(n//100+n)
elif d==1:
    ans=100*(n//100+n)
else:
    ans=10000*(n//100+n)
print(ans)