Harryxun/stf_run huggingface dataset:
N=int(input())
A=list(map(int,input().split()))

eachbit=[0]*30
for i in range(N):
    bin_str = format(A[i],'030b')
#    print(bin_str)
    for j in range(31):
        if bin_str[-j] == '1':
            eachbit[j] += 1

even = True
for e in eachbit:
    if e % 2 != 0:
        even = False

if even:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

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

eachbit=[0]*32
for i in range(N):
    bin_str = format(A[i],'032b')
#    print(bin_str)
    for j in range(1,33):
        if bin_str[-j] == '1':
            eachbit[j-1] += 1

#print(eachbit)
even = True
for e in eachbit:
    if e % 2 != 0:
        even = False

if even:
    print('Yes')
else:
    print('No')
import itertools
S=input()
T=input()

n=len(T)
Thatena=[[T[j] if (i>>j)&1 else "?" for j in range(n)] for i in range(2**n)] #Tのうち0文字以上を?に置き換えたものの集合
#print(Thatena)
#print(len(Thatena))
ans=[]
for t in Thatena:
    if S.find("".join(t))!=-1:
        anslist.append(S.rfind("".join(t)))
        break
if anslist==[]:
    print("UNRESTORABLE")
    exit()
#print(anslist[0],anslist[0]+len(T))
ans=S[:anslist[0]]+T+S[anslist[0]+len(T):]
print("".join([c if c!="?" else "a" for c in ans]))

### FIXED CODE ###

import re
S = input().replace('?', '.')
T = input()
for i in range(len(S)-len(T), -1, -1):
    if re.match(S[i:i+len(T)], T):
        S = S.replace('.', 'a')
        print(S[:i]+T+S[i+len(T):])
        exit()
print('UNRESTORABLE')
n,q = input().split()
n = int(n)
q = int(q)
T = [0] * (n+5)
A = [0] * (n+5)
B = [0] * (n+5)
P = [0] * (q+5)
X = [0] * (q+5)
for i in range(1,n):
    A[i],B[i] = [int(j) for j in input().split()]
for i in range(1,q+1):
    P[i],X[i] = [int(j) for j in input().split()]

NIL = -1

class node:
    def __init__(self):
        self.value = 0
        self.child = []
        self.parent = NIL

def childadd(T,x):
    if T[x].child != []:
        for i in range(len(T[x].child)):
            T[T[x].child[i]].value += T[x].value
            childadd(T,T[x].child[i])

for i in range(1,n+1):
    T[i] = node()

for i in range(1,n):
    T[B[i]].parent = T[A[i]]
    T[A[i]].child.append(B[i])

for i in range(1,q+1):
    T[P[i]].value += X[i]

childadd(T,1)

for i in range(1,n+1):
    print(T[i].value,end = " ")


### FIXED CODE ###

from collections import deque

n,q = input().split()
n = int(n)
q = int(q)
T = [0] * (n+1)

to = [[] for i in range(n+1)]
cnt = [0] * (n)
for i in range(1,n):
    a,b = [int(j) for j in input().split()]
    to[a].append(b)
    to[b].append(a)
for i in range(1,q+1):
    P,X = [int(j) for j in input().split()]
    T[P] += X
NIL = -1

q =deque()
q.append((1,0,NIL))
while len(q)>0:
    p,x,prev = q.pop()
    x += T[p]
    cnt[p-1] = x
    for i in to[p]:
        if i != prev:
            q.append((i,x,p))
print(*cnt)
import sys
sys.setrecursionlimit(10 ** 7)
from math import factorial as f
n, blue = map(int, input().split())
red = n - blue
mod = 10 ** 9 + 7


def p(n, r):
    return f(n) // f(n-r)


def c(n, r):
    return p(n, r) // f(r)


for i in range(1, blue + 1):
    space = c(red + 1, i)
    pattern = c(blue - 1, blue - i)
    print(space * pattern % mod)


### FIXED CODE ###

from math import factorial as f
n, blue = map(int, input().split())
red = n - blue
mod = 10 ** 9 + 7


def p(n, r):
    return f(n) // f(n-r)


def c(n, r):
    return p(n, r) // f(r)


for i in range(1, blue + 1):
    if red < i - 1:
        print(0)
    else:
        space = c(red + 1, i)
        pattern = c(blue - 1, blue - i)
        print(space * pattern % mod)
N = int(input())
# h,n,w
temp = int((3*N)/4)
if (temp >= 3500):
    temp = 3500
hlist = [i for i in range(temp,0,-1)]
flag = False
for i in hlist:
    temp = 4/N - 1/i
    if(temp > 0):
        al = int(2 / temp)
        if (al >= 3500):
            al = 3500
        nlist = [ii for ii in range(al,0,-1)]
        for j in nlist:
            beta = 4/N - 1/i - 1/j
            if (beta > 0):
                if(1/beta == int(1/beta)):
                    w = int(1/beta)
                    n = j
                    h = i
                    flag = True
                    break

    if flag:
        break

print(str(h)+ " " + str(n)+ " " +str(w))

### FIXED CODE ###

N = int(input())
flag = False
for i in range(1,3500):
    for j in range(1,3500):
        if((4*i*j - N*i - N*j) > 0 and (N*i*j)%(4*i*j - N*i - N*j) == 0):
            w = int((N*i*j)/(4*i*j - N*i - N*j))
            h = i
            n = j
            flag = True
            break
    if flag:
        break

print(h,n,w)
A=int(input())
B=int(input())
L=[1,2,3]
p=L.pop(A-1)
q=L.pop(B-1)
print(L[0])

### FIXED CODE ###

A=int(input())
B=int(input())
print(6-A-B)
#! /usr/bin/env python3
# -*- coding: utf-8 -*-

S = input()
ls = list(S)
ls = [int(x) for x in ls]
offset = 0
count = 0
while len(ls) >= 2:
    if ls[offset] != ls[offset +1]:
        del ls[offset:offset +2]
        count += 2
        offset = 0
    elif offset + 1 == len(ls):
        break
    else:
        offset += 1

print(count)

### FIXED CODE ###

#! /usr/bin/env python3
# -*- coding: utf-8 -*-

S = input()
ls = list(S)
ls = [int(x) for x in ls]

ans = min(ls.count(0),ls.count(1))
print(ans*2)
import math
??
r = input()
r = float(r)
??
area = math.pi * (r ** 2)
length = 2 * math.pi * r
??
print("{0:.5f} {1:.5f}".format(area, length))

### FIXED CODE ###

import math
r = float(input())
 
s = r * r *  math.pi
l = (r + r) * math.pi
 
print('%.5f %.5f' % (s, l))
print(1000-N%1000)

### FIXED CODE ###

n=int(input())
if n%1000==0:
  print(0)
else:
  print(1000-n%1000)
n,k=map(int,input().split())
A=list(map(int,input().split()))
p=1
l=[0]*n
#l[0]+=1
if k<=100000:
    for i in range(k):
        p=A[p-1]
        l[p-1]+=1
    print(p)
    exit()
else:
    for i in range(100001):
        p=A[p-1]#A[0]の番号の町に飛ぶ
        l[p-1]+=1
        #print(p)
        if l[p-1]==2:
            x=i
            break
    #print("p=",str(p))
    #print(l,x)

    d=1
    for j in range(100001):
        d=A[d-1]#A[0]の番号の町に飛ぶ
        if d==p:
            y=j
            break
    #print("y=",str(y))
    z=(k-x-1)%(x-y)#yから数えて残り回す回数
    #print(z)
    for i in range(z):
        p=A[p-1]
        print(p)

### FIXED CODE ###

n,k=map(int,input().split())
A=list(map(int,input().split()))
p=1
l=[0]*n
#l[0]+=1
if k<=200000:
    for i in range(k):
        p=A[p-1]
        l[p-1]+=1
    print(p)
    exit()
else:
    for i in range(200001):
        p=A[p-1]#A[0]の番号の町に飛ぶ
        l[p-1]+=1
        #print(p)
        if l[p-1]==2:
            x=i
            break
    #print("p=",str(p))
    #print(l,x)

    d=1
    for j in range(200001):
        d=A[d-1]#A[0]の番号の町に飛ぶ
        if d==p:
            y=j
            break
    #print("y=",str(y))
    z=(k-x-1)%(x-y)#yから数えて残り回す回数
    #print(z)
    for i in range(z):
        p=A[p-1]
        #print(p)
    print(p)
n,r = map(int,input().split())
print(r-(100*(10-n))

### FIXED CODE ###

n,r = map(int,input().split())
print(r+(100*(max(10-n,0))))
N= input()
F = 0
for i in range(8):
  F += int(N[i])
if N%F== 0:
  print("Yes")
else:
  print("No")


### FIXED CODE ###

N= int(input())
F = 0
t = N
for i in range(9):
  a = N // (10**(8-i))
  F += a
  N = N - a*(10**(8-i))
if t % F== 0:
  print("Yes")
else:
  print("No")
import numpy as np
N,K=map(int, input().split())
A =list(map(int,input().split()))
MOD = 10 ** 9 + 7
#if N==K:
#  ans0 = 1
#  for a in A[0:N]:
#    ans0 *= a
#    ans0 %= MOD
#  print(ans0)
#  exit()

A=sorted(A)  
if (K%2==1 and A[-1]<0):
  ans1 = 1
  for a in A[N-K:N]:
    ans1 *= a
    ans1 %= MOD
  print(ans1)
  exit()

A=sorted(A, key=lambda x:abs(x), reverse=True)
AA=[np.sign(i) for i in A]
 
ansA = 1
for a in A[0:K]:
  ansA *= a
  ansA %= MOD
ansAA = AA[0:K].count(-1)%2
if ansA==0 or ansAA==0:
  print(ansA)
  exit()

#while ansA>0:
#  ansA-=MOD

B1=A[0:K]
C1=A[0:K]
B2=sorted(A[K:N])
Bp=[i for i in A[0:K] if i>0]
Bm=[i for i in A[0:K] if i<0]
 
if B2[0]>0:B2.insert(0,0)
if B2[-1]<0:B2.insert(-1,0)
if not Bp:Bp.insert(0,B1[-1])
if not Bm:Bm.insert(0,B1[0])
  
B1.remove(Bp[-1])
B1.append(min(B2[0],0))

ansB = 1
for a in B1[0:K]:
  ansB *= a
  ansB %= MOD

C1.remove(Bm[-1])
C1.append(max(B2[-1],0))
 
ansC = 1
for a in C1[0:K]:
  ansC *= a
  ansC %= MOD

BB1=[np.sign(i) for i in B1]
ansBB1 = BB1[0:K].count(-1)%2
BB2=[np.sign(i) for i in C1]
ansBB2 = BB2[0:K].count(-1)%2

if ansBB1==1:
  print(ansC)
  exit()
if ansBB2==1:
  print(ansB)
  exit()

if abs(Bp[-1]*B2[-1])-abs(Bm[-1]*B2[0])>=0:
  print(ansC)
else: print(ansB)

### FIXED CODE ###

import numpy as np
N,K=map(int, input().split())
A =list(map(int,input().split()))
MOD = 10 ** 9 + 7
if N==K:
  ans0 = 1
  for a in A[0:N]:
    ans0 *= a
    ans0 %= MOD
  print(ans0)
  exit()
A=sorted(A)  
if (K%2==1 and A[-1]<0):
  ans1 = 1
  for a in A[N-K:N]:
    ans1 *= a
    ans1 %= MOD
  print(ans1)
  exit()
 
A=sorted(A, key=lambda x:abs(x), reverse=True)
AA=[np.sign(i) for i in A]
 
ansA = 1
for a in A[0:K]:
  ansA *= a
  ansA %= MOD
ansAA = AA[0:K].count(-1)%2
if ansA==0 or ansAA==0:
  print(ansA)
  exit()

while ansA>0:
  ansA-=MOD

B1=A[0:K]
C1=A[0:K]
B2=sorted(A[K:N])
Bp=[i for i in A[0:K] if i>0]
Bm=[i for i in A[0:K] if i<0]
 
if B2[0]>0:B2.insert(0,0)
if B2[-1]<0:B2.insert(-1,0)
if not Bp:Bp.insert(0,B1[-1])
if not Bm:Bm.insert(0,B1[0])
  
#print(Bp,Bm,B2)
#print(Bp[-1],B2[0])
B1.remove(Bp[-1])
B1.append(min(B2[0],0))
#print(B1)
ansB = 1
for a in B1[0:K]:
  ansB *= a
  ansB %= MOD
#print(Bm[-1],B2[-1])
C1.remove(Bm[-1])
C1.append(max(B2[-1],0))
 
ansC = 1
for a in C1[0:K]:
  ansC *= a
  ansC %= MOD
#print(B1,C1)
#print(ansB,ansC)
BB1=[np.sign(i) for i in B1]
ansBB1 = BB1[0:K].count(-1)%2
BB2=[np.sign(i) for i in C1]
ansBB2 = BB2[0:K].count(-1)%2
#print(ansBB1,ansBB2)
if ansBB1==1:
  print(ansC)
  exit()
if ansBB2==1:
  print(ansB)
  exit()
#print(B2[0]/Bp[-1],B2[-1]/Bm[-1])
#print(Bp[-1]*B2[-1],Bm[0]*B2[0])

#print(abs(Bp[-1]*B2[-1])-abs(Bm[-1]*B2[0]))
#print(ansB,ansC)
if abs(Bp[-1]*B2[-1])-abs(Bm[-1]*B2[0])>=0:
  print(ansC)
else: print(ansB)
N, M = map(int, input().split())
p = [int(i) for i in input().split()]

class Unionfind:
    def __init__(self, num):
        self.num = num
        self.par = [int(i) for i in range(num+1)]

    def root(self, x):
        if self.par[x] == x:
            return x
        else:
            return self.root(self.par[x])

    def unite(self, u, v):
        ru = self.root(u)
        rv = self.root(v)
        if ru != rv:
            self.par[ru] = rv

    def same(self, u, v):
        return self.root(u) == self.root(v)

uni = Unionfind(N)
for i in range(M):
    x, y = map(int, input().split())
    uni.unite(x, y)

count = 0
for i in range(1, N+1):
    if uni.same(i, p[i-1]):
        count += 1

print(count)


### FIXED CODE ###

N, M = map(int, input().split())
p = [int(i) for i in input().split()]

class Unionfind:
    def __init__(self, num):
        self.par = [i for i in range(num+1)]
        self.rank = [0] * (num+1)

    def root(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.root(self.par[x])
            return self.par[x]

    def unite(self, u, v):
        ru = self.root(u)
        rv = self.root(v)
        if self.rank[ru] < self.rank[rv]:
            self.par[ru] = rv
        else:
            self.par[rv] = ru
            if self.rank[ru] == self.rank[rv]:
                self.rank[ru] += 1

    def same(self, u, v):
        return self.root(u) == self.root(v)

uni = Unionfind(N)
for i in range(M):
    x, y = map(int, input().split())
    uni.unite(x, y)

count = 0
for i in range(1, N+1):
    if uni.same(i, p[i-1]):
        count += 1

print(count)
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
dx = (0, 0, 1, -1)
dy = (1, -1, 0, 0)
seen = [[False] * w for _ in range(h)]

numb = 0
numw = 0


def dfs(x, y):
    global numb, numw
    seen[x][y] = True
    if s[x][y] == '#':
        numb += 1
    else:
        numw += 1
    for di in range(4):
        nx = x + dx[di]
        ny = y + dy[di]
        if (nx < 0 or nx >= h or ny < 0 or ny >= w):
            continue
        if s[x][y] == s[nx][ny]:
            continue
        if seen[nx][ny]:
            continue
        dfs(nx, ny)


ans = 0
for x in range(h):
    for y in range(w):
        if seen[x][y]:
            continue
        if s[x][y] == '.':
            continue
        numb = 0
        numw = 0
        dfs(x, y)
        ans += numb * numw
print(ans)


### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
dx = (0, 0, 1, -1)
dy = (1, -1, 0, 0)
seen = [[False] * w for _ in range(h)]

numb = 0
numw = 0


def dfs(x, y):
    global numb, numw
    seen[x][y] = True
    if s[x][y] == '#':
        numb += 1
    else:
        numw += 1
    for di in range(4):
        nx = x + dx[di]
        ny = y + dy[di]
        if (nx < 0 or nx >= h or ny < 0 or ny >= w):
            continue
        if s[x][y] == s[nx][ny]:
            continue
        if seen[nx][ny]:
            continue
        dfs(nx, ny)


ans = 0
for x in range(h):
    for y in range(w):
        if seen[x][y]:
            continue
        if s[x][y] == '.':
            continue
        numb = 0
        numw = 0
        dfs(x, y)
        ans += numb * numw
print(ans)
a, b, c = map(int, input().split())
print("YES" if b-a == c-b else "NO)


### FIXED CODE ###

a, b, c = map(int, input().split())
print("YES" if b-a == c-b else "NO")
"""負辺ありの有向グラフの最短経路問題、ベルマンフォード法"""

n,m,p = map(int, input().split())

INF = 1001001001

to = [[] for _ in range(2505)]
rto = [[] for _ in range(2505)]
reachableFrom1 = [False for _ in range(2505)]
reachableToN = [False for _ in range(2505)]
ok = [False for _ in range(2505)]

def dfs(v):
    """1から到達できる頂点の列挙"""
    if reachableFrom1[v]: return
    reachableFrom1[v] = True
    for u in to[v]:
        dfs(u)

def rdfs(v):
    """Nに到達できる頂点の列挙"""
    if reachableToN[v]: return
    reachableToN[v] = True
    for u in rto[v]:
        rdfs(u)

edges = []
for i in range(m):
    a,b,c = map(int, input().split())
    a -= 1; b -= 1
    c -= p
    c = -c
    edges.append((a,b,c))
    to[a].append(b) # 到達可能性を判定するための変数
    rto[b].append(a) # nに辿り着けるかを判定するための変数
    
dfs(0)
rdfs(n-1)

for i in range(n):
    ok[i] = reachableFrom1[i] & reachableToN[i] # okになっている頂点だけを考える

# ベルマンフォード
def main():
    global edges
    d = [INF for _ in range(n)]
    d[0] = 0
    upd = True
    step = 0 # 負閉路検出用。更新回数がnステップを超えたら負閉路あり
    while upd:
        upd = False
        for i in range(m):
            a,b,c = edges[i]
            if not ok[a]: continue
            if not ok[b]: continue
            newD = d[a]+c
            if newD < d[b]:
                upd = True
                d[b] = newD
        step += 1
        if step > n:
            print(-1)
            return
    ans = -d[n-1]
    ans = max(ans,0)
    print(ans)
    return
    
main()

### FIXED CODE ###

"""負辺ありの有向グラフの最短経路問題、ベルマンフォード法"""
import sys
sys.setrecursionlimit(10**6)

n,m,p = map(int, input().split())

INF = 1001001001

to = [[] for _ in range(2505)]
rto = [[] for _ in range(2505)]
reachableFrom1 = [False for _ in range(2505)]
reachableToN = [False for _ in range(2505)]
ok = [False for _ in range(2505)]

def dfs(v):
    """1から到達できる頂点の列挙"""
    if reachableFrom1[v]: return
    reachableFrom1[v] = True
    for u in to[v]:
        dfs(u)

def rdfs(v):
    """Nに到達できる頂点の列挙"""
    if reachableToN[v]: return
    reachableToN[v] = True
    for u in rto[v]:
        rdfs(u)

edges = []
for i in range(m):
    a,b,c = map(int, input().split())
    a -= 1; b -= 1
    c -= p
    c = -c
    edges.append((a,b,c))
    to[a].append(b) # 到達可能性を判定するための変数
    rto[b].append(a) # nに辿り着けるかを判定するための変数
    
dfs(0)
rdfs(n-1)
for i in range(n):
    ok[i] = reachableFrom1[i] & reachableToN[i] # okになっている頂点だけを考える
# ベルマンフォード
def main():
    global edges, ok
    d = [INF for _ in range(n)]
    d[0] = 0
    upd = True
    step = 0 # 負閉路検出用。更新回数がnステップを超えたら負閉路あり
    while upd:
        upd = False
        for i in range(m):
            a,b,c = edges[i]
            if not ok[a]: continue
            if not ok[b]: continue
            newD = d[a]+c
            if newD < d[b]:
                upd = True
                d[b] = newD
        step += 1
        if step > n:
            print(-1)
            return
    ans = -d[n-1]
    ans = max(ans,0)
    print(ans)
    return
    
main()
int b
b = a + a^2 + a^3
return b

### FIXED CODE ###

import sys

a = int(input())
print(a + a**2 + a**3)
from dateutil.relativedelta import relativedelta

x = int(raw_input())
x = "{0.hours:02}:{0.minutes:02}:{0.seconds:02}".format(relativedelta(seconds=x))
print(x)


### FIXED CODE ###

x = int(raw_input())
m = x/60
h = m/60
m = m%60
s = x%60
print(str(h)+":"+str(m)+":"+str(s))
import sys

N = int(input())

if N == 1:
    print(1)
    sys.exit()
    
A = sorted(set(map(int, input().split())))

if len(A) == 1:
    print(0)
    sys.exit()
    
max = A[-1]
memo = ['Y'] * (10**6+1)
ans = 0
 
for i, A_i in enumerate(A):
    if memo[A_i] == 'N':
        continue
    for j in range(A_i, max+1, A_i):
        memo[j] = 'N'
    if i != N-1 and A_i == A[i+1]:
        continue
    ans += 1
    
print(ans)

### FIXED CODE ###

N = int(input())
A = sorted(list(map(int, input().split())))
max = A[-1]
memo = ['Yes'] * (10**6+1)
ans = 0
 
for i, A_i in enumerate(A):
    if memo[A_i] == 'No':
        continue
    for j in range(A_i, max+1, A_i):
        memo[j] = 'No'
    if i != N-1 and A_i == A[i+1]:
        continue
    ans += 1
 
print(ans)
a, b, c = [int(i) for i in input().split()]
nums = 0
for i in range(a,c+1)
    if b%i ==0 and bet%i ==0:
        nums = nums + 1
    else:
        pass
   
print(nums)

### FIXED CODE ###

a, b, c = [int(i) for i in input().split()]
nums = 0
for i in range(a, b + 1):
    if c%i == 0:
        nums = nums + 1
    else:
        pass
print(nums)
import numpy as np
import math

def kochCurve(p1, p2, n):
  if n == 0:
    print(p2[0], p2[1])
    return

  v = (p2 - p1)/3
  s = p1 + v
  t = s + v

  theta = math.atan2(v[1], v[0])

  a = np.linalg.norm(t - s)
  h = 3**(1/2)*a/2
  u = s + (t - s)/2 + np.array([h*math.sin(theta), h*math.cos(theta)])

#  print(n, p1, s, u, t, p2)

  n -= 1
  kochCurve(p1, s, n)
  kochCurve(s, u, n)
  kochCurve(u, t, n)
  kochCurve(t, p2, n)

if __name__ == "__main__":
  n = int(input())
  print(0, 0)
  kochCurve(np.array([0, 0]), np.array([100, 0]), n)

### FIXED CODE ###

import math

def kochCurve(p1, p2, n):
  if n == 0:
    print(p2[0], p2[1])
    return

  v = [(p2[0]-p1[0])/3, (p2[1]-p1[1])/3]
  s = [p1[0]+v[0], p1[1]+v[1]]
  t = [s[0]+v[0], s[1]+v[1]]

  theta = math.atan2(v[1], v[0]) + math.pi/2

  a = math.sqrt((t[0]-s[0])**2+(t[1]-s[1])**2)
  h = 3**(1/2)*a/2
  u = [s[0]+(t[0]-s[0])/2+h*math.cos(theta), s[1]+(t[1]-s[1])/2+h*math.sin(theta)]

  n -= 1
  kochCurve(p1, s, n)
  kochCurve(s, u, n)
  kochCurve(u, t, n)
  kochCurve(t, p2, n)

if __name__ == "__main__":
  n = int(input())
  print(0, 0)
  kochCurve([0, 0], [100, 0], n)
a,b = map(float,input().split())
b *=100
print(int(a*b//100))a

### FIXED CODE ###

a,b = input().split()
a = int(a)
b = int(b.replace(".",""))
print(int(a*b//100))
from math import *
import sys

N = int(input())
all_input_list = [list(map(int, input().split())) for i in range(N)]
x, y, h = [all_input_list[i] for i in range(N) if all_input_list[i][2] > 0][0]
for cx in range(101):
    for cy in range(101):
        H = h + abs(cx - x) + abs(cy - y)
        for input_list in all_input_list:
            result = H - abs(cx - input_list[0]) -  abs(cy - input_list[1])
            if (result < 0) or (input_list[2] != result):
                break
        else:
            print("%s %s %s" % (cx, cy, H))
            sys.exit(0)

### FIXED CODE ###

print("Hello World") if(input() == "1") else print(int(input()) + int(input()))
a=int(input())
b=int(input())
print(f"{a*b}{(a+b)*2}")


### FIXED CODE ###

a,b=map(int,input().split())
print(a*b,(a+b)*2)
import sys
N, M = map(int, input().split())
sc = [list(map(int, input().split())) for _ in range(M)]

if N == 1 and sc[0][1] == 0:
    print(0)
    sys.exit()

A = [-1] * N
A[0] = 1
for i in range(M):
    if sc[i][0] == 1 and sc[i][1] == 0:
        print('-1')
        sys.exit()
    if sc[i][0] != 1 and A[sc[i][0] - 1] != -1 and A[sc[i][0] - 1] != sc[i][1]:
        print('-1')
        sys.exit()
    A[sc[i][0] - 1] = sc[i][1]
for a in A:
    if a == -1:
        a = 0
    print(a, end='')
print('')

### FIXED CODE ###

import sys
N, M = map(int, input().split())
sc = [list(map(int, input().split())) for _ in range(M)]

if N == 1 and M == 0:
    print(0)
    sys.exit()
if N == 1 and sc[0][1] == 0:
    print(0)
    sys.exit()

A = [-1] * N
for i in range(M):
    if sc[i][0] == 1 and sc[i][1] == 0:
        print('-1')
        sys.exit()
    if A[sc[i][0] - 1] != -1 and A[sc[i][0] - 1] != sc[i][1]:
        print('-1')
        sys.exit()
    A[sc[i][0] - 1] = sc[i][1]
if A[0] == -1:
    A[0] = 1
for a in A:
    if a == -1:
        a = 0
    print(a, end='')
print('')
n=int(input())
list = list(map(int,input().slice()))
cnt=0
for i in range(1,n-1):
    if list[i-1]<list[i]<list[i+1]:
        cnt+=1
    elif list[i-1]>list[i]>list[i+1]:
        cnt+=1
print(cnt)

### FIXED CODE ###

n=int(input())
li =list(map(int,input().split()))
cnt=0
for i in range(1,n-1):
    if li[i-1]<li[i]<li[i+1]:
        cnt+=1
    elif li[i-1]>li[i]>li[i+1]:
        cnt+=1
print(cnt)
a = []
for line in sys.stdin:
	if line="0"
    a.append(int(line))
    if len(a>10000):
    	break

for i in range(len(a)):
	print("Case ",i+1,": ",a[i],sep="")

### FIXED CODE ###

a = []
while True:
    n = input()
    if n == "0":
        break
    a.append(n)


for i in range(len(a)):
	print("Case ",i+1,": ",a[i],sep="")
n = int(input())
a = []
for _ in range(n):
  a.append(int(input())
           
print(len(set(a)))

### FIXED CODE ###

n = int(input())
a = []
for _ in range(n):
  a.append(int(input()))
           
print(len(set(a)))
N, K = map(int, input().split())
A = map(int, input().split())

count = {}

for a in A:
    count[a] = count.get(a, 0) + 1

tmp = []
for k, v in count:
    tmp.appned(v)

tmp = sorted(tmp)

total = 0
for i in range(len(sorted_) - K):
    total += tmp[i]

print(total)

### FIXED CODE ###

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

count = {}

for a in A:
    count[a] = count.get(a, 0) + 1

tmp = []
for k, v in count.items():
    tmp.append(v)

tmp = sorted(tmp)

total = 0
for i in range(len(tmp) - K):
    total += tmp[i]

print(total)
import math
from decimal import *
A, B, H, M = map(int,input().split())
# 長針の角度
long = 6 * M
# 短針の角度
short = 30*(H) + 0.5*M
if long < short:
    theta = short - long
else:
    theta = lomg - short
if theta > 180:
    theta = 360 - theta
cos = math.cos(math.radians(theta))
x = A**2 + B**2 - 2*A*B*cos
x = math.sqrt(x) # 平方根に変換
n = 10 # 小数点10位以下を切り捨て
y = Decimal(str(x)).quantize(Decimal(str(10**(n*-1))), rounding=ROUND_DOWN)
print(y)


### FIXED CODE ###

import math
from decimal import *
A, B, H, M = map(int,input().split())
# 長針の角度
long = 6 * M
# 短針の角度
short = 30*(H) + 0.5*M
theta = abs(long - short)
if theta > 180:
    theta = 360 - theta
cos = math.cos(math.radians(theta))
x = A**2 + B**2 - 2*A*B*cos
x = math.sqrt(x) # 平方根に変換
n = 10 # 小数点10位以下を切り捨て
y = Decimal(str(x)).quantize(Decimal(str(10**(n*-1))), rounding=ROUND_DOWN)
print(y)
n = input()
x = input()
t = input()

print((n//x+1)*t)

### FIXED CODE ###

import math

N, x, T = map(int, input().split())

print(math.ceil(N / x) * T)
N = input()
kisuu = -(-N // 2)
print(kisuu / N)

### FIXED CODE ###

N = int(input())
kisuu = -(-N // 2)
print(kisuu / N)
import sys
for xy in sys.stdin:
    x, y  = xy.split()
    i   if x == '0' and y == '0':
        break
    elif int(x) > int(y):
        x, y = y, x
    print('%s %s'%(x, y))

### FIXED CODE ###

import sys
for xy in sys.stdin:
    x, y  = xy.split()
    if x == '0' and y == '0':
        break
    elif int(x) > int(y):
        x, y = y, x
    print('%s %s'%(x, y))
D,N = map(int, input().split())

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

### FIXED CODE ###

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

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