peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Wrong Answer
N=int(input())
for x in range(1,10):
    for y in range (1,10):
        if x*y==N:
            print('Yes')
else:
    print('No')
# Judge status: Wrong Answer
N = int(input())
s = [int(input()) for _ in range(N)]

ten = 0
other = []

for num in s:
  if num % 10 == 0:
    ten += num
  else:
    other.append(num)
    
if other:
  other.sort()
  print(ten + sum(other[1:]))
  
else:
  print(0)
# Judge status: Wrong Answer
S, W = [int(x) for x in input().split()]

if S <= 2 * W:
    print('unsafe')
else:
    print('safe')
# Judge status: Wrong Answer
# coding: utf-8
from math import factorial
N, P = map(int, input().split())
A = list(map(int, input().split()))
odd, even = 0, 0
for i in range(N):
    if A[i] % 2 == 0:
        even += 1
    else:
        odd += 1
ans = 0
if P == 0:
    ans += 2 ** even
    v = ans
    ans += (odd * (odd-1)) // 2 * max(1, v)
else:
    for i in range(1, odd, 2):
        ans += factorial(odd) // (factorial(i) * factorial(odd - i)) * 2**even
print(ans)
# Judge status: Wrong Answer
S = list(input())
T = list(input())
ls = len(S)
lt = len(T)
ans = lt
for offset in range(ls - lt + 1):
	cnt = 0
	for i in range(lt):
		if S[offset + i] != T[i]:
			cnt += 1
	ans = min(lt, cnt)
print(ans)
# Judge status: Accepted
def main():
    x, y = map(int, input().split())

    ans = 0

    while y >= x:
        x *= 2
        ans += 1
        
    print(ans)

if __name__ == '__main__':
    main()
# Judge status: Accepted
n=int(input())
a=[[int(i)for i in input().split()]for i in range(n)]
import itertools as it
li=list(it.permutations(range(n)))
total=0
for i in li:
    tmp=0
    for j in range(n-1):
        x1,x2=a[i[j]][0],a[i[j+1]][0]
        y1,y2=a[i[j]][1],a[i[j+1]][1]
        tmp=(x1-x2)**2+(y1-y2)**2
        total+=tmp**0.5
print(total/len(li))
# Judge status: Accepted
import math
a,b,x = map(int,input().split())
x = x/a

if x >a*b/2:
    theta = math.degrees(math.atan2(2*(a*b-x)/a,a))
else:
    theta = math.degrees(math.atan2(b,2*x/b))
print(theta)
# Judge status: Accepted
x,y = map(int,input().split())
ans = abs(abs(x) - abs(y))
if(x*y>0)&(x>y):
    ans += 2
if(x*y < 0):
    ans += 1
if(x*y==0)&(x>y):
    ans += 1
print(ans)
# Judge status: Accepted
N = int(input())
arms = []
ans = 1
for i in range(N):
    X,L = (int(x) for x in input().split())
    arms.append((X-L,X+L))
arms.sort(key=lambda x:x[1])
limit = arms[0][1]
for x in arms[1:]:
    if x[0] < limit:
        continue
    else:
        limit = x[1]
        ans += 1
print(ans)
# Judge status: Accepted
a,b,k = map(int,input().split())
frm = min(a, b)
cnt = 0
for i in range(frm, 0, -1):
    if a % i == 0 and b % i == 0:
        cnt += 1
    if cnt == k:
        print(i)
        exit()
# Judge status: Accepted
a, b, c, k = map(int,input().split())
if k % 2 == 0:
  print(a-b)
else:
  print(b-a)
# Judge status: Wrong Answer
N = int(input())
a = list(map(int,input().split()))
count = 0
i = 0
while i+1 != a[i]:
  a.pop(i)
  count += 1
  if i+1 == a[i]:
    i += 1
  if a == []:
    print(-1)
    exit()
  if len(a) == a[-1]:
    print(count)
    exit()
# Judge status: Wrong Answer
#n=int(input())
n,m=map(int,input().split())
#a=list(map(int,input().split()))
l=[list(map(int,input().split())) for i in range(m)]

ll=[[]for i in range(n)]

for i in range(m):
    ll[l[i][0]-1].append(l[i][1])
    ll[l[i][1]-1].append(l[i][0])

lt=[0 for i in range(n)]
lll=[1]
for i in range(n):
    for j in ll[lll[i]-1]:
        lll.append(j)
    lll=list(dict.fromkeys(lll))
    print(lll)
# Judge status: Wrong Answer
from math import sqrt

N, D = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(N)]
ans = 0

for i in range(N - 1):
    dist = 0

    for j in range(i + 1, N):
        for k in range(D):
            dist += (X[i][k] - X[j][k]) ** 2
        
        if sqrt(dist) % 1 == 0:
            ans += 1
    
print(ans)
# Judge status: Wrong Answer
def Csum(a):
    b,c=[0],0
    for i in range(len(a)):
        c+=a[i]
        b.append(c)
    return b

n=int(input())
a=list(map(int,input().split()))
s=Csum(a)
su=sum(a)
b=1
c=0
for i in range(n+1):
    c+=b
    b-=a[i]
    if b<=0:
        if i==n:
            break
        print(-1)
        exit()
    b=min(b*2,su-s[i+1])
print(c)
# Judge status: Accepted
s = list(input())
i , j= 0, len(s) - 1
while True:
    if s[i] == "A":
        break
    i += 1
while True:
    if s[j] == "Z":
        break
    j -= 1
print(j - i + 1)
# Judge status: Wrong Answer
ans_list = []
z_count = 0
for i in range(5):
    b = int(input())
    c = b%10
    ans_list.append((b,c))
    if c == 0:
        z_count += 1
ans_list.sort(key = lambda x:x[1], reverse = True)
count = 0
ans = 0
for i in range(5-z_count):
    if ans_list[i][1] is not 0:
        ans += (ans_list[i][0] -ans_list[i][1] + 10)
    else:
        ans += ans_list[i][0]
ans -=(10-ans_list[5-z_count-1][1])
for i in range(z_count):
    ans += ans_list[5-z_count+ i][0]

print(ans)
# Judge status: Accepted
N=int(input())
plus=[input() for i in range(N)]
M=int(input())
minus=[input() for i in range(M)]
S=list(set(plus+minus))
ans=[]
for i in S:
    point=0
    point=plus.count(i)-minus.count(i)
    ans.append(point)
money=max(ans)
if money>0:
    print(money)
else:
    print(0)
# Judge status: Accepted
import math
X=int(input())
y=1
z=100
for _ in range(X):
    if math.floor(z*1.01) >= X:
        print(y)
        break
    else:
        z=math.floor(z*1.01)
        y +=1
# Judge status: Accepted
from collections import Counter
n, *A = map(int, open(0).read().split())
ans = 0
for v in  Counter(A).values():
  if v % 2 == 1:
    ans += 1
print(ans)
# Judge status: Accepted
a,b,c,d=input()
print('Good' if a!=b and b!=c and c!=d else 'Bad')
# Judge status: Wrong Answer
N = int(input())
A = list(map(int,input().split()))

B = [0]*N
for i in range(N):
    B[A[i]-1] = i+1
print(B)
# Judge status: Accepted
a, b = map(int, input().split())
k = b - a - 1
a_k = (k + 1) * (k + 2) //2
x = a_k -b
print(x)
# Judge status: Accepted
K=int(input())
A,B=map(int,input().split())
ans='NG'
for i in range(A,B+1):
    if i%K==0:
        ans='OK'
        break
print(ans)
# Judge status: Wrong Answer
n, l = map(int, input().split())
m = 300
ls = []
for i in range(l, l+n):
    m = min(abs(m), abs(i))
    ls.append(i)
print(sum(ls) - m)
# Judge status: Accepted
import sys
input = sys.stdin.readline

s = input().rstrip()

l = len(s)

print("x" * l)
# Judge status: Accepted
a = input()

if a.isupper() == True:
  print('A')
elif a.islower() == True:
  print('a')
# Judge status: Accepted
def main():
    h, a = map(int, input().split())
    if h % a == 0:
        ans = h // a
    else:
        ans = h // a + 1
    print(ans)

if __name__ == '__main__':
    main()
# Judge status: Wrong Answer
n,k=map(int,input().split())
a=list(map(int,input().split()))
ans=float('inf')

for i in range(0,n-k+1):
  b=a[i]
  c=a[i+k-1]
  if c<=0:
    ans=min(ans,abs(b)-abs(c))
  elif b>=0:
    ans=min(ans,abs(c)-abs(b))
  else:
    ans=min(ans,abs(c)+abs(b)*2,abs(c)*2+abs(b))
    
print(ans)
# Judge status: Wrong Answer
S=input()
for i in range(3):
  if S[i]==S[i+1]:
    print("Bad")
    break
  else:
    print("Good")
# Judge status: Wrong Answer
N = int(input())

def nega_binary(num):
	res = []
	while num != 0:
		remainder = abs(num) % 2
		res.append(str(remainder))
		if num < 0 and remainder:
			num -= 1
		num = int(num / -2)

	return ''.join(reversed(res))

print(nega_binary(N))
# Judge status: Wrong Answer
str = input()
out = ["x"]*len(str)
 
print(out)
# Judge status: Accepted
A1,A2,A3 = map(int,input().split())
if A1+A2+A3 <=21:
  print('win')
else:
  print('bust')
# Judge status: Wrong Answer
d,n=map(int,input().split());print((100**d)*n)
# Judge status: Accepted
w = ['SUN', 'MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT']
s = input()
print(7 - w.index(s))
# Judge status: Wrong Answer
h1, m1, h2, m2, k = [int(i) for i in input().split()]

awake = 60*h2+m2 - (60*h1+m1) - k
print(k)
# Judge status: Accepted
D=int(input())
c=list(map(int,input().split()))
s=[list(map(int,input().split())) for _ in range(D)]

last=[0]*26


for d in range(1,D+1):
    ans=[]
    for choice in range(1,27):
        ans_tmp=0
        ans_tmp+=s[d-1][choice-1]
        for i in range(26):
            if i+1==choice:
                continue
            ans_tmp-=c[i]*(d-last[i]+1)
        ans.append((ans_tmp,choice))
    _,case=max(ans)
    last[case-1]=d
    print(case)
# Judge status: Accepted
a,b,c,k = list(map(int,input().split()))	
x = 10 **18
result = a - b
if result > x:
    print("Unfair")
elif k % 2 == 0:
    print(result)
elif k % 2 == 1:
    result = result * -1
    print(result)
# Judge status: Wrong Answer
N,M=map(int,input().split())
stu=[]
for i in range(N):
  a,b=map(int,input().split())
  stu.append([a,b])
pl=[]
for j in range(M):
  c,d=map(int,input().split())
  pl.append([c,d])
for k in range(N):
  met=2*(10**8)
  pr=0
  for l in range(M):
    if abs(pl[l][0]-stu[k][0])+abs(pl[l][1]-stu[k][1])<met:
      met=abs(pl[l][0]-stu[k][0])+abs(pl[l][1]-stu[k][1])
      pr=l+1
  print(pr)
# Judge status: Wrong Answer
a="PD"*100000+"P"
s=input()
n=len(s)
r=""
c=0
for i in range (n):
    if s[i]=='?':
        c+=1
    else:
        if c%2==0:
            r+=a[0:c]
        else:
            r+=a[1:c+1]
        r+=s[i]
print(r)
# Judge status: Accepted
Q,H,S,D = map(int,input().split())
N = int(input())
h = min(2*Q,H)
s = min(2*h,S)
d = min(2*s,D)
print((N//2)*d + (N%2)*s)
# Judge status: Accepted
from math import gcd

k=int(input())
ans=0

for a in range(1,k+1) :
    for b in range(1,k+1) :
        for c in range(1,k+1) :
            ans+=gcd(gcd(a,b),c)

print(ans)
# Judge status: Wrong Answer
n, m = map(int, input().split())

if n == m == 1:
    print(0)
elif min(n, m) == 1:
    print(max(0, max(n,m)-2))
elif min(n,m) == 2:
    print(0)
else:
    print((n-2) * (m-2))
# Judge status: Accepted
n,a,b,c,d=map(int,input().split())
s=input()
if c<d:
    print("No" if "##" in s[a-1:d] else "Yes")
else:
    print("Yes" if "##" not in s[a-1:c] and "..." in s[b-2:d+1] else "No")
# Judge status: Accepted
import math

if __name__ == '__main__':
    n = int(input())
    ans_div = 0
    limit = math.ceil(math.sqrt(n))
    for i in range(1, limit + 1):
        if n % i == 0:
            ans_div = max(ans_div, i)
    print(ans_div + n // ans_div - 2)
# Judge status: Accepted
n , k = map(int,input().split())
print((n-2)//(k-1)+1)
# Judge status: Accepted
def main():
    N = int(input())
    V = sorted(map(int, input().split()))
    ave = V[0]
    for v in V[1:]:
        ave = (ave + v) / 2
    print(ave)
main()
# Judge status: Accepted
N,M = map(int,input().split())
H = list(map(int,input().split()))

data = [[] for i in range(N)]
for i in range(M):
    A,B = map(int,input().split())
    A -= 1
    B -= 1
    data[A].append(B)
    data[B].append(A)

ans = 0

for i in range(N):
    det = 1
    for x in data[i]:
        if H[i] <= H[x]:
            det = 0
            break
    ans += det

print(ans)
# Judge status: Accepted
n, k = map(int, (input().split()))
s = input()

c = sum([s[i:i + 2] in ('LR', 'RL') for i in range(n - 1)])

print(n - c - 1 + int(min(c / 2, k) * 2))
# Judge status: Accepted
input() #Nはすてる
A = list(map(lambda x: int(x), input().split()))
denied = False
for a in A:
  if a%2==0:
    if a%3!=0 and a%5!=0:
      print('DENIED')
      denied = True
      break
if denied==False:
  print('APPROVED')
# Judge status: Accepted
#!/usr/bin/env python3
# -*- coding: utf-8 -*-


def main():
    N = int(input())
    S = input()
    x = 0
    xm = 0
    for i in range(N):
        if S[i] == 'I':
            x+=1
        else :
            x-=1
        if xm < x:
            xm = x
    print(xm)


if __name__ == "__main__":
    main()
# Judge status: Accepted


N = int(input())
abc = []
for _ in range(N):
    abc.append( list(map(int,input().split())) ) 

dp = [abc[0]]
for i in range(1,N):
    dp.append([ abc[i][0] + max(dp[i-1][1],dp[i-1][2]),\
                abc[i][1] + max(dp[i-1][2],dp[i-1][0]), \
                abc[i][2] + max(dp[i-1][0],dp[i-1][1]) ])
print(max(dp[N-1]))
# Judge status: Accepted
a = input()
if a in ["a","e","i","o","u"]:
    print("vowel")
else:
    print("consonant")
# Judge status: Wrong Answer
n, x = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
for i in range(n):
    x = x - a[i]
    if x >= 0:
        continue
    else:
        print(i)
        break
if x >= 0:
    print(i+1)
# Judge status: Accepted
n=int(input())
ans=0
if n%2==0:
  n//=2
  while(n>0):
    n//=5
    ans+=n
 
print(ans)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
Q = int(input())

for _ in range(Q):
  B, C = map(int, input().split())
  count = A.count(B)
  if count >0:
    A.remove(B)
    A.extend([C]*count)
  print(sum(A))
# Judge status: Accepted
N = int(input())
tot = 0
for d in range(1, N+1):
    nd = N//d
    tot += (d * (nd + 1) * nd) // 2

print(tot)
# Judge status: Accepted
w,h,x,y=map(int, input().split())

if x==w/2 and y==h/2:
    cnt=1
else:
    cnt=0
print(w*h/2, cnt)
# Judge status: Accepted
s = input()
k = int(input())
ok = True
char = '1'
for i in range(k):
	if s[i] != '1':
		ok = False 
		char = s[i]
		break
if ok:
	print(1)
else:
	print(char)
# Judge status: Accepted
import re
s = input()
m = re.search(r'A.*Z', s).group()
print(len(m))
# Judge status: Wrong Answer
from math import factorial
def cmb(n,r):
    if n-r<0:
        return 0
    else:
        return factorial(n) // factorial(r) // factorial(n - r)
        

n,p,*a=map(int,open(0).read().split())

odd=sum(i%2 for i in a)
even=n-odd

print(odd,even)

x=sum(cmb(even,i)for i in range(even+1))
y=sum(cmb(odd,i)for i in range(p,odd+1,2))
print(x*y)
# Judge status: Accepted
x = int(input())
a = 0
b = 0

for i in range(120):
    for j in range(-100, 120):
        if i**5 - j**5 == x:
            a = i
            b = j

print(str(a)+" "+str(b))
# Judge status: Accepted
# coding: utf-8
N = int(input())
S = input()
e, w = 0, 0
e = S.count("E")
ans = e
for i in range(N):
    if S[i] == "E":
        e -= 1
        ans = min(ans, e+w)
    else:
        w += 1
print(ans)
# Judge status: Accepted
n = int(input())
A = list(map(int,input().split()))
B = sorted(A)
med = B[n//2-1:n//2+1]

for a in A:
  if a  <= med[0]:
    print(med[1])
  else:
    print(med[0])
# Judge status: Accepted
def main():
    n, *a, = map(int, open(0).read().split())
    a = [x - i for i, x in enumerate(a, 1)]
    a.sort()
    if n % 2 == 0:
        ans = sum(a[n // 2:]) - sum(a[:n // 2])
    else:
        ans = sum(a[n // 2 + 1:]) - sum(a[:n // 2])
    print(ans)


if __name__ == '__main__':
    main()
# Judge status: Accepted
N,*a = map(int,open(0).read().split())

a = sorted(a)
ans = 0
for i in range(N):
  ans += a[-2-2*i]
print(ans)
# Judge status: Accepted
X=int(input())
ans=0
for i in range(X,2*X+1):
    for j in range(2,i):
        if i%j!=0:
            ans+=1
    if ans==i-2:
        print(i)
        exit()
    else:
        ans=0
# Judge status: Wrong Answer
N, K = map(int, input().split())
A=[]
i=0
m=0
for _ in range(2*K):
    a = [int(x) for x in input().split()]
    if i%2!=0:
        A.append(a)
    i=i+1
A = list(map(list, set(map(tuple, A))))
print(N-len(A))
# Judge status: Wrong Answer
import sys
# N=5
# A=[6, 7, 9, 10, 31]
N=map(int,input())
A=list(map(int, input().split()))

A_even=[]
for i in A:
    if  (i%2)==0:
        A_even.append(i)
for i in A_even:
    if (i%3)==0 and (i%5)==0:
        print("DENIED")
        sys.exit()
print("APPROVED")
# Judge status: Accepted
n=(int)(input())
ans =1
for i in range(n):
  for j in range(n):
    p=j+2
    if i**p <=n:
      ans=max(ans,i**p)
    else:
      break
print(ans)
# Judge status: Accepted
def resolve():
    K, S = map(int, input().split())
    count = 0
    for x in range(K + 1):
        for y in range(K + 1):
            if S - K <= x + y <= S and max(x, y) <= K:
                count += 1
    print(count)


if __name__ == "__main__":
    resolve()
# Judge status: Accepted


s = input()
t = input()

t_tmp = t[0:len(t)-1]
if s == t_tmp:
    print('Yes')
else:
    print('No')
# Judge status: Wrong Answer

n = int(input())
s = list(input())
x = []
y = []
ans = []

for i in range(1,n):
    x = s[0:i]
    y = s[i:n]
    print(x)
    print(y)

    for j in range(len(x)):
        a = 0
        if y.count(x[j]) >= 1:
            a += 1
    ans.append(a)
    print(ans)

print(max(ans))
# Judge status: Wrong Answer
n,m=map(int,input().split())
if n==1:
  print(m-2)
elif m==1:
  print(n-2)
elif n>=3 and m>=3:
  print((n-2)*(m-2))
else:
  print(0)
# Judge status: Accepted
n = int(input())
s = input()
a = [0]*n
a[0] = s[1:].count('E')
for i in range(1,n):
    if s[i-1] == 'W':
        a[i] = a[i-1]+1
    else:
        a[i] = a[i - 1]
    if s[i] == 'E':
        a[i] -= 1
print(min(a))
# Judge status: Accepted
N = input()

if (N[0] == N[1] and N[1] == N[2]) or N[1] == N[2] and N[2] == N[3]:
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
N=int(input())
t0=0
x0=0
y0=0

for i in range(N):
  t1,x1,y1=map(int,input().split())
  AbsT=t1-t0
  AbsX=abs(x1-x0)
  AbsY=abs(y1-y0)
  if AbsX+AbsY>AbsT or (AbsX+AbsY-AbsT)%2!=0:
    print("No")
    break

else:
  print("Yes")
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

point = 0
for i in range(N):
    point += B[A[i]-1]
    if i+1 < N and A[i]+1 == A[i+1]:
        point += C[i-1]
print(point)
# Judge status: Accepted
a, b = map(int,input().split())
if a > 8 or b > 8:
  print(":(")
else:
  print("Yay!")
# Judge status: Accepted
N, K, Q = map(int,input().split())
A = [int(input()) for i in range(Q)]

if K > Q:
    for i in range(N):
        print("Yes")

else:
    B = []
    for i in range(N):
        B.append(K - Q)

    for i in range(Q):
        ans = A[i] - 1
        P = B[ans] + 1
        B[ans] = P

    for i in range(N):
        if B[i] > 0:
            print("Yes")
        else:
            print("No")
# Judge status: Accepted
n, k = map(int, input().split())
ans = 0
while n > 0:
    n = n // k
    ans += 1
print(ans)
# Judge status: Accepted
X, Y = map(int, input().split())
cnt = 1
while True:
    X *= 2
    if X > Y:
        break
    cnt += 1
print(cnt)
# Judge status: Accepted
a,b,c,d,e = map(int,input().split())

print(60*(c-a)+d-b-e)
# Judge status: Wrong Answer
a,b = map(int,input().split())
l = map(int,input().split())
l = sorted(l)
print(l)
print(sum(l[:b]))
# Judge status: Accepted
def combination_mod(n, k, mod=10 ** 9 + 7):
    if k > n:
        return 1

    nu, de = 1, 1
    for i in range(k):
        nu = nu * (n - i) % mod
        de = de * (i + 1) % mod
    return nu * pow(de, mod - 2, mod) % mod


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

mod = 10 ** 9 + 7
ans = pow(2, n, mod) - 1
ans -= combination_mod(n, a)
ans = (ans + mod) % mod
ans -= combination_mod(n, b)
ans = (ans + mod) % mod
print(ans)
# Judge status: Accepted
n=int(input())
x=sorted(map(int,input().split()))
ans=x[0]
for i in range(1,n):
    ans=ans*x[i]
    if ans>=10**18:
        break
print(-1 if ans>10**18 else ans)
# Judge status: Wrong Answer
x = int(input("子供の数を入力してね:"))

n = 0

for i in range(1,x+1):
    n += i

print(n)
# Judge status: Accepted
def mul(n):
  s=1
  for t in range(1,n+1):
    s=s*t
  return s

def f(x):
  result=0
  N=len(x)
  for i in range (N):
    k=0
    for j in range(i,N):
      if x[i]>x[j]:
        k=k+1
    result=result+k*mul(N-i-1)
  return result

N=int(input())
P=list(map(int,input().split()))
Q=list(map(int,input().split()))

print(abs(f(P)-f(Q)))
# Judge status: Accepted
from collections import defaultdict as dd
def beautiful(s):
    D = dd(lambda:0)
    for c in s:
        D[c] += 1
    if any(d&1 for d in D.values()):
        return False
    else:
        return True

print('Yes' if beautiful(input()) else 'No')
# Judge status: Wrong Answer
num = int(input())
a_i = list(map(int, input().split()))
s = 0
for x in a_i:
    s ^= x
ans = []
for x in a_i:
    ans.append(x ^ s)
print(ans)
# Judge status: Wrong Answer
n = int(input())
l = list(map(int,input().split()))
l1 = [0,0]
from collections import Counter
c = Counter(l)
for i in c.items():
  if i[1]>=2:
    l1.append(i[0])
print(l1[-1]*l1[-2])
# Judge status: Accepted
s = input()
if s == "abc" or s == "acb" or s == "bac" or s == "bca" or s == "cab" or s == "cba":
  print("Yes")
else:
  print("No")
# Judge status: Wrong Answer
def main():
    d,n=map(int,input().split())
    print(100**d*(n))
    
if __name__ == "__main__":
    main()
# Judge status: Wrong Answer
N=int(input())
A=list(map(int,input().split()))
B=[-1]*N
for i in range(N):
    for j in range(N):
        if A[j]==i+1:
            B[i]=j+1
            break
print(B)
# Judge status: Accepted
#coding: utf-8
import math
import heapq
import bisect
import numpy as np
#from scipy.misc import comb

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

city = []
for i in range(M):
    p,y = map(int, input().split())
    city.append([i,p,y,0])

city = sorted(city, key=lambda x:(x[1],x[2]))

city[0][3] = 1
no = 2
for i in range(1,M):
    if city[i][1] != city[i-1][1]:
        no = 1
    city[i][3] = no
    no += 1

city = sorted(city, key=lambda x:x[0])

for c in city:
    print('{0:06d}{1:06d}'.format(c[1],c[3]))
# Judge status: Accepted
a, b, c = map(int, input().split())
print(c,a,b)
# Judge status: Accepted
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
k=int(input())
if (e-a)<=k:
  print('Yay!')
else:
  print(':(')
# Judge status: Wrong Answer
print('ABC' if input() == 'ARS' else 'ARS')
# Judge status: Accepted
N,L=map(int,input().split())
taste=[]
taste_abs=[]
for i in range(N):
    taste+=[(L+i)]
    taste_abs+=[abs(L+i)]

idx=taste_abs.index(min(taste_abs))
del taste[idx]
print(sum(taste))
# Judge status: Accepted
s=list(map(int,list(input())))
ans0=0
ans1=0
pre=s[0]
for si in s[1:]:
  if si==pre:
    ans0+=1
    pre=not si
  else:
    pre=si

pre=s[-1]
for si in s[:-1][::-1]:
  if si==pre:
    ans1+=1
    pre=not si
  else:
    pre=si
print(min(ans0,ans1))
# Judge status: Accepted
N = int(input())
ans = 0

for n in range(1, N+1):
    cnt = 0
    if n%2 == 0:
        continue
    for yaku in range(1, n+1):
        if n%yaku == 0:
            cnt += 1
    if cnt == 8:
        ans += 1
        
print(ans)
# Judge status: Wrong Answer
import sys
sys.setrecursionlimit(10**6)

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

newa=sorted(a)

#print(a)
#print(newa)
#print(newa[2])

if newa[2]%2==0:
    print("0")
else:
    print(a[0]*a[1])
# Judge status: Accepted
cost = int(input())
itien = int(input())
if itien >= cost % 500:
  print("Yes")
else:
  print("No")
# Judge status: Accepted
import math

x = int(input())
money = 100
time = 0

while(money < x):
    money = math.floor(money * 1.01)
    time += 1

print(time)
# Judge status: Accepted
import queue

N = int(input())
A = list(map(int, input().split()))
A.sort(reverse = True)
q = queue.Queue()

ans = A[0]
q.put( (A[0], A[1]) )
q.put( (A[0], A[1]) )
for i in range(2, len(A)):
  t = q.get()
  ans += min(t[0], t[1])
  q.put((t[0], A[i]))
  q.put((t[1], A[i]))
  
print(ans)
# Judge status: Wrong Answer
r,g,b=map(int, input().split())

if (g*10 + b) %4==0:
    print("Yes")

else:
    print("No")
# Judge status: Accepted
k, x = map(int, input().split())
if 500*k >= x:
  print('Yes')
else:
  print('No')
# Judge status: Accepted
def main():
    a,b,c = map(int,input().split())
    if(c-a-b<=0):
        print("No")
    elif(4*a*b<(c-a-b)**2):                                                                                                  print("Yes")
    else:
        print("No")
if __name__ == "__main__":
    main()
# Judge status: Accepted
x = int(input())
if x % 2 == 0 or x % 5 == 0:
  print(-1)
else:
  s = 1
  m = 7
  
  while m%x != 0:
    n = m % x
    m = n * 10 +7
    s += 1
    
  
  print(s)
# Judge status: Wrong Answer
n=int(input())
s=input()
wc=[0]
ec=[0]
for i in range(n):
    if s[i]=="W":
        wc.append(wc[i]+1)
        ec.append(ec[i])
    else:
        wc.append(wc[i])
        ec.append(ec[i]+1)
ans=10**6
for i in range(n):
    tmp=0
    
    tmp+=wc[i]
    tmp+=ec[n]-ec[i]
    ans=min(tmp,ans)
print(ans)
# Judge status: Wrong Answer
a,b,c=map(int,input().split())

if a<=b and b<=c:
  print("Yes")
else:
  print("No")