Harryxun/stf_run huggingface dataset:
X, Y, Z, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
D = [0] * (X * Y)
F = [0] * (X * Y * Z)
m, n = 0, 0

for i in range(X):
	for j in range(Y):
		D[m] = A[i] + B[j]
		m += 1

Dsort = sorted(D)[:: -1]
E = Dsort[: K]

for k in range(len(E)):
	for l in range(Z):
		F[n] = E[k] + C[l]
		n += 1

for p in range(K):
	print(sorted(F)[:: -1][p])


### FIXED CODE ###

X, Y, Z, K = map(int, input().split())
A, B, C = [sorted(list(map(int, input().split())))[:: -1][: K] for _ in range(3)]
D = []
for ai in A:
    for bi in B:
        D.append(ai + bi)

D = sorted(D)[:: -1][: K]

res = []
for di in D:
    for ci in C:
        res.append(di + ci)

res = sorted(res)[:: -1][: K]

for ans in res:
    print(ans)
from collections import*
import sys
sys.stdin=input
n=int(input())
a=list(map(int,input().split()))
a=Counter(a)
cnt=1
for i in range(min(a),max(a)+1):
	cnt_=a[i-1]+a[i]+a[i+1]
	if cnt_>cnt:cnt=cnt_
print(cnt)

### FIXED CODE ###

from collections import*
import sys
input=sys.stdin.readline
n=int(input())
a=list(map(int,input().split()))
a=Counter(a)
cnt=1
for i in range(min(a),max(a)+1):
	cnt_=a[i-1]+a[i]+a[i+1]
	if cnt_>cnt:cnt=cnt_
print(cnt)
import math
a, b = map(int, input().split())
res = int(a*b / math.gcd(a, b))
print(res)

### FIXED CODE ###

import fractions as fr
a, b = map(int, input().split())
res = int(a*b / fr.gcd(a, b))
print(res)
MAX = 10**9 + 7

def solve():
    N = int(raw_input())
    arr = [int(_) for _ in raw_input().split()]
    xor_acu = [0] * (N + 1)
    for i in range(1, N + 1):
        xor_acu[i] = xor_acu[i - 1] ^ arr[i - 1]
    if xor_acu[N] != 0: # search for 0, X, 0, X ..., 0, X type
        X = xor_acu[N]
        dp0 = [1] * (N + 1)
        dpX = [0] * (N + 1)
        for i in range(1,N+1):
            dp0[i] = dp0[i-1] + dpX[i-1] if xor_acu[i] == 0 else dp0[i - 1]
            dpX[i] = dp0[i-1] + dpX[i-1] if xor_acu[i] == X else dpX[i - 1]
        ret = dp0[N - 1]
    else: # search for 0, X, 0, X ..., X, 0 type
        # X == 0 case
        tmp = 1
        Not0Set = set()
        for i in range(1, N):
            if xor_acu[i] == 0:
                tmp *= 2
            else:
                Not0Set.add(xor_acu[i])
        ret = tmp
        if ret > MAX:
            ret = ret % MAX
        # X != 0 case
        for X in list(Not0Set):
            RLE = [] # Run Length Encoding
            _tmp = xor_acu[0]
            cnt = 1
            all_cnt = 1
            for i in range (1, N+1):
                if xor_acu[i] == 0 or xor_acu[i] == X:
                    if xor_acu[i] == _tmp:
                        cnt += 1
                    else:
                        RLE.append((_tmp, cnt))
                        _tmp = xor_acu[i]
                        cnt = 1
                    all_cnt += 1
            RLE.append((_tmp, cnt))
            lRLE = all_cnt
            Not0dp0 = [1] * lRLE
            Not0dpX = [0] * lRLE
            ind = 1
            for i in range(len(RLE)):
                start = 1 if i == 0 else 0
                if RLE[i][0] == 0:
                    for j in range(start, RLE[i][1]):
                        Not0dp0[ind] = Not0dp0[ind - 1] + Not0dpX[ind - 1]
                        Not0dpX[ind] = Not0dpX[ind - 1]
                        ind += 1
                else:
                    for j in range(start, RLE[i][1]):
                        Not0dp0[ind] = Not0dp0[ind - 1]
                        Not0dpX[ind] = Not0dp0[ind - 1] + Not0dpX[ind - 1]
                        ind += 1
            ret += Not0dpX[ind - 2]
            if ret > MAX:
                ret = ret % MAX
    print str(ret)

if __name__ == '__main__':
    solve()


### FIXED CODE ###

def solve():
    N, K = [int(_) for _ in raw_input().split()]
    ret = N - K + 1
    print str(ret)

if __name__ == '__main__':
    solve()
def DFS(i):
    for j in range(n):
        if A[i][j] == 1 and d[j] == 0:
            time = time + 1
            d[j] = time
            DFS(j)
    time = time + 1
    f[i] = time

n = int(raw_input())
A = [0] * n
for i in range(n):
    A[i] = [0] * n

for i in range(n):
    value = map(int, raw_input().split())
    u = value[0] - 1
    k = value[1]
    nodes = value[2:]
    for i in range(k):
        v = nodes[i] - 1
        A[u][v] = 1

d = [0] * n
f = [0] * n
time = 1
d[0] = time
DFS(0)

for i in range(n):
    print(str(i + 1) + " " + str(d[0]) + " " + str(f[0]))
 

### FIXED CODE ###


def DFS(n = 1, i = 0, time = 1):
    for j in range(n):
        if A[i][j] == 1 and d[j] == 0:
            time = time + 1
            d[j] = time
            time = DFS(n, j, time)
    time = time + 1
    f[i] = time
    return time

n = int(raw_input())
A = [0] * n
for i in range(n):
    A[i] = [0] * n

for i in range(n):
    value = map(int, raw_input().split())
    u = value[0] - 1
    k = value[1]
    nodes = value[2:]
    for j in range(k):
        v = nodes[j] - 1
        A[u][v] = 1

d = [0] * n
f = [0] * n

time = 0
for i in range(n):
    if d[i] == 0:
        time = time + 1
        d[i] = time
        time = DFS(n, i, time)

for i in range(n):
    print(str(i + 1) + " " + str(d[i]) + " " + str(f[i]))
import sympy
sympy.factorint(2016)

### FIXED CODE ###

N, M = map(int, input().split())
mod = 10**9 + 7


def factorize(n):
    b = 2
    fct = {}
    while b * b <= n:
        while n % b == 0:
            n //= b
            if b in fct.keys():
                fct[b] += 1
            else:
                fct[b] = 1
        b = b + 1
    if n > 1:
        fct[n] = 1
    return fct


from operator import mul
from functools import reduce


def cmb(n, r):
    r = min(n-r, r)
    if r == 0:
        return 1
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1, r + 1))
    return over // under


fac_list = factorize(M)
ans = 1
for k, v in fac_list.items():
    ans *= cmb(v+N-1, v)
    if ans >= mod:
        ans %= mod

print(int(ans))
def calc(n):
    i=1
    sm = 0
    st = set()
    if n<=2:
        st.add(n)
        return st
    while sm<=n:
        st.add(i)
        sm += i
        i+=1
    st = st - calc(sm-n)
    return st

n = int(input())

c = calc(n)

for cc in c:
    print(cc)

### FIXED CODE ###

import sys


def calc(n):
    i = 1
    sm = 0
    st = set()
    if n <= 2:
        st.add(n)
        return st
    while sm < n:
        st.add(i)
        sm += i
        i += 1
    st = st - calc(sm - n)
    return st


sys.setrecursionlimit(10000000)
n = int(input())

c = calc(n)

for cc in c:
    print(cc)
n = int(raw_input())
A = map(int, raw_input().strip().split(' '))
q = int(raw_input())
M = map(int, raw_input().strip().split(' '))
def ans(i, m):
    if m == 0:
        return 1
    if i  >= n or m > sum(A):
        return 0
    res = ans(i + 1, m) or ans(i + 1, m - A[i])
    return res
           
for j in range(0, q):
    if ans(0, m[j]):
        print "yes"
    else:
        print"no"

### FIXED CODE ###

n = int(raw_input())
A = map(int, raw_input().strip().split(' '))
q = int(raw_input())
M = map(int, raw_input().strip().split(' '))

def ans(i, m):
    if m == 0:
        return 1
    if i  >= n or m > sum(A):
        return 0
    res = ans(i + 1, m) or ans(i + 1, m - A[i])
    return res
           
for j in range(0, q):
    if ans(0, M[j]):
        print "yes"
    else:
        print"no"
while True:
    x = input()
    if x == 0:
        break
    table = x.split()
    print(sum(table))



### FIXED CODE ###

while True:
  x = sum(map(int, input()))

  if x == 0:
    break

  print(x)
N,Q = (int(x) for x in input().split())
connection ={i:set() for i in range(1,N+1)}
for i in range(N-1):
    a,b = (int(x) for x in input().split())
    connection[a].add(b)
    connection[b].add(a)
#point =OrderedDict({i:0 for i in range(1,N+1)})
point ={i:0 for i in range(1,N+1)}
for i in range(Q):
    p,x = (int(x) for x in input().split())
    point[p] +=x
 
def DFS(now,prev = -1):
    for next in connection[now]:
        if next == prev:
            continue
        point[next] +=point[now] 
        DFS(next,now)
 
DFS(1)
print(*point.values())

### FIXED CODE ###

from collections import deque
 
N, Q = map(int, input().split())
Ki = [[] for _ in range(N)]
for _ in range(N-1):
    p, c = map(int, input().split())
    Ki[p-1].append(c-1)
    Ki[c-1].append(p-1)
S = [0]*N
for _ in range(Q):
    node, score = map(int, input().split())
    S[node-1] += score
 
stack = deque([0])
done = [0]*N
done[0] = 1
 
while len(stack) > 0:
    now = stack.pop()
    
    for new in Ki[now]:
        if done[new] == 0:
            done[new] = 1
            stack.append(new)
            S[new] += S[now]
    
print(*S)
# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

X, Y, A, B, C = LI()
p = LI()
q = LI()
r = LI()

p.sort(reverse= 1)
q.sort(reverse= 1)
r.sort(reverse= 1)

def solve():
    ans = 0
    p_selected = p[:X]
    q_selected = q[:Y]
    p_selected.sort()
    q_selected.sort()
    p_cnt = 0
    q_cnt = 0
    r_selected = r[:min((X + Y), len(r))]
    # print(p_selected, q_selected)

    ans += sum(p_selected) + sum(q_selected)
    for r_i in r_selected:
        if p_selected[p_cnt] > q_selected[q_cnt] and q_cnt < Y:
            if q_selected[q_cnt] < r_i:
                ans += r_i - q_selected[q_cnt]
                q_cnt += 1
            else:
                return ans
        else:
            if p_selected[p_cnt] < r_i:
                ans += r_i - p_selected[p_cnt]
                p_cnt += 1
            else:
                return ans
    return ans

ans = solve()

print(ans)

### FIXED CODE ###

# encoding:utf-8
import copy
import random
import bisect #bisect_left　これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections

mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000

d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))

X, Y, A, B, C = LI()
p = LI()
q = LI()
r = LI()

p.sort(reverse= 1)
q.sort(reverse= 1)
r.sort(reverse= 1)

def solve():
    ans = 0
    p_selected = p[:X]
    q_selected = q[:Y]
    p_selected.sort()
    q_selected.sort()
    p_cnt = 0
    q_cnt = 0
    r_selected = r[:min((X + Y), len(r))]
    # print(p_selected, q_selected)

    ans += sum(p_selected) + sum(q_selected)
    for r_i in r_selected:
    
        if q_cnt < Y and p_cnt < X:
            if p_selected[p_cnt] >= q_selected[q_cnt]:
                if q_selected[q_cnt] < r_i:
                    ans += r_i - q_selected[q_cnt]
                    q_cnt += 1
                else:
                    return ans
            elif p_selected[p_cnt] < q_selected[q_cnt]:
                if p_selected[p_cnt] < r_i:
                    ans += r_i - p_selected[p_cnt]
                    p_cnt += 1
                else:
                    return ans
        elif q_cnt < Y and p_cnt >= X:
            if q_selected[q_cnt] < r_i:
                ans += r_i - q_selected[q_cnt]
                q_cnt += 1
            else:
                return ans
        elif p_cnt < X and q_cnt >= Y:
            if p_selected[p_cnt] < r_i:
                ans += r_i - p_selected[p_cnt]
                p_cnt += 1
            else:
                return ans

    return ans

ans = solve()

print(ans)
r = input()
print(3*(r**2))

### FIXED CODE ###

r = int(input())
print(3*(r**2))
def main():
    import sys
    N,K=list(map(int,sys.stdin.readline().split()))
    P=list(map(int,sys.stdin.readline().split()))
    C=list(map(int,sys.stdin.readline().split()))

    output=-10**12

    lst=[[0]*(N+1) for _ in range(N)]
    for i in range(N):
        st=set()
        now=i
        count=0
        score=0
        while True:
            count+=1
            now=P[now]-1

            if now in st:
                count-=1
                break
    
            lst[i][count]=lst[i][count-1]+C[now]
            st.add(now)
            
            if count==K:
                break
        
        if lst[i][count]>0 and K>=count:
            if K%count:
                s=lst[i][count]*(K//count)+max(lst[i][1:K%count+1])
            else:
                s=lst[i][count]*(K//count)
        else:
            s=max(lst[i][1:count+1])
        output=max(output,s)

    print(lst)
    print(output)

main()

### FIXED CODE ###

def main():
    import sys
    N,K=list(map(int,sys.stdin.readline().split()))
    P=list(map(int,sys.stdin.readline().split()))
    C=list(map(int,sys.stdin.readline().split()))

    output=-10**20

    lst=[[0]*(N+1) for _ in range(N)]
    for i in range(N):
        st=set()
        now=i
        count=0
        score=0
        if K==1:
            output=max(output,C[P[i]-1])
            continue

        while True:
            count+=1
            now=P[now]-1

            if now in st:
                count-=1
                break
    
            lst[i][count]=lst[i][count-1]+C[now]
            st.add(now)
            
            if count==K:
                break


        if lst[i][count]>0:
            m=max(lst[i][1:count+1])
            
            if K%count:
                p=max(lst[i][1:K%count+1])
                if p>0:
                    s=lst[i][count]*(K//count)+p
                else:
                    s=lst[i][count]*(K//count-1)+m
            else:
                s=lst[i][count]*(K//count-1)+m
        else:
            s=max(lst[i][1:count+1])
        
        output=max(output,s)

    print(output)

main()
N,M = map(int,input().split())
A = [input().split() for i in range(M)]
s1=list()
s2=list()
p=0
w=0
for i in range(M):
    if A[i][0] not in s2 and A[i][1]=="WA":
        s1 +=A[i][0]
        print(s1)
    if A[i][0] not in s2 and A[i][1]=="AC":
        p+=1 
        s2 +=A[i][0]
        w += int(s1.count(A[i][0]))
        print(s1,s2)
print(p,w)

### FIXED CODE ###

N,M = [int(x) for x in input().split()]
count = [0]*N
ac = 0
wa = 0
ireta = []
for i in range(M):
    a,b = input().split()
    a = int(a)
    if b == "AC" and count[a-1] == 0:
        count[a-1] = 1
        ac += 1
    elif count[a-1] == 0:
        ireta.append(a)
        wa += 1
for i in range(len(ireta)):
    if count[ireta[i]-1] == 0:
        wa -= 1
print(ac,wa)
A=int(input())
B=int(input())
C=int(input())
D=int(input())
E=int(input())
a=A%10
b=B%10
c=C%10
d=D%10
e=E%10
result=0
if a==0:
    result+=A
else:
    result+=(A+10-a)
if b==0:
    result+=B
else:
    result+=(B+10-b)
if c==0:
    result+=C
else:
    result+=(C+10-c)
if d==0:
    result+=D
else:
    result+=(D+10-d)
if e==0:
    result+=E
else:
    result+=(E+10-e)

l=set([a,b,c,d,e])
l.discard(0)

print(result-(10-min(l)))


### FIXED CODE ###

A=int(input())
B=int(input())
C=int(input())
D=int(input())
E=int(input())
a=A%10
b=B%10
c=C%10
d=D%10
e=E%10
result=0
if a==0:
    result+=A
else:
    result+=(A+10-a)
if b==0:
    result+=B
else:
    result+=(B+10-b)
if c==0:
    result+=C
else:
    result+=(C+10-c)
if d==0:
    result+=D
else:
    result+=(D+10-d)
if e==0:
    result+=E
else:
    result+=(E+10-e)
if a==b==c==d==e==0:
    print(result)
else:
    l=set([a,b,c,d,e])
    l.discard(0)
    print(result-(10-min(l)))
n = int(input())
a =[int(input()) for i in range(n)]
b = []
for i in range(n):
    for j in range(i+1, n+1):
        b.append(a[j]-a[i])
    
c = sorted(b, reverse = True)
print(c[0])
        


### FIXED CODE ###

n = int(input())
a = [int(input()) for i in range(n)]
ma = a[1]-a[0]
mi = a[0]
for i in range(1,n):
    ma = max(ma, a[i] - mi)
    mi = min(mi, a[i])
    
print(ma)
sys.setrecursionlimit(10000000)
N = int(input())
JU = [-1] * N

LI = [[] for _ in range(N)]
for _ in range(N-1):
    u,v,w = map(int,input().split())
    W = w%2
    LI[u-1].append([v-1,W])
    LI[v-1].append([u-1,W])
def dfs(x):
    for i in range(len(LI[x])):
        j = LI[x][i][0]
        k = LI[x][i][1]
        if JU[j] == -1:
            if JU[i] == 0:
                if k == 0:
                    JU[j] = 0
                    dfs(j)
                else:
                    JU[j] = 1
                    dfs(j)
            else:
                if k == 0:
                    JU[j] = 1
                    dfs(j)
                else:
                    JU[j] = 0
                    dfs(j)

for i in range(N):
    if JU[i] == -1:
        JU[i] = 0
        dfs(i)
for i in range(N):
    print(JU[i])

### FIXED CODE ###

import sys
sys.setrecursionlimit(10000000)
N = int(input())
JU = [-1 for _ in range(N)]

LI = [[] for _ in range(N)]
for _ in range(N-1):
    u,v,w = map(int,input().split())
    W = w%2
    LI[u-1].append([v-1,W])
    LI[v-1].append([u-1,W])
def dfs(x):
    for i in range(len(LI[x])):
        j = LI[x][i][0]
        k = LI[x][i][1]
        if JU[j] == -1:
            if JU[x] == 0:
                if k == 0:
                    JU[j] = 0
                    dfs(j)
                else:
                    JU[j] = 1
                    dfs(j)
            else:
                if k == 0:
                    JU[j] = 1
                    dfs(j)
                else:
                    JU[j] = 0
                    dfs(j)

JU[0] = 0
dfs(0)
for i in range(N):
    print(JU[i])
line = input()
r = int(line)

import math

print('%f %f' % (r*r*math.pi, 2*r*math.pi) )

### FIXED CODE ###

line = input()
r = float(line)

import math

print('%f %f' % (r*r*math.pi, 2*r*math.pi) )
H,W=map(int,input())
if H%2==0:
    print(H//2*W)
elif W%2==0:
    print(W//2*H)
else:
    print((H//2)*W+((W+1)//2))


### FIXED CODE ###

H,W=map(int,input().split())
if H==1 or W==1:
    print(1)
elif H%2==0:
    print(H//2*W)
elif W%2==0:
    print(W//2*H)
else:
    print((H//2)*W+((W+1)//2))
a = input()
if a.islower():
  ptint('a')
else:
  print('A')

### FIXED CODE ###

ch = input()
if ch == 'a' or ch == 'b' or ch == 'c' or ch == 'd' or ch == 'e' or ch == 'f' or ch == 'g' or ch == 'h':
  print('a')
elif ch == 'i' or ch == 'j' or ch == 'k' or ch == 'l' or ch == 'm' or ch == 'n' or ch == 'o':
  print('a')
elif ch == 'p' or ch == 'q' or ch == 'r' or ch == 's' or ch == 't' or ch == 'u' or ch == 'v':
  print('a')
elif ch == 'w' or ch == 'x' or ch == 'y' or ch == 'z':
  print('a')
else:
 print('A')
s = list(input().split())
ans="No"
if s[0]==s[1] and s[2]==s[3] or s[0]==s[2] and s[1]==s[3] or s[0]==s[3] and s[1]==s[2]:
	ans="Yes"
print(ans)


### FIXED CODE ###

s = sorted(input())


if s[0]!=s[1] or s[2]!=s[3] or s[0]==s[3]:
	print("No")
else :
	print("Yes")
n, a, b = map(int, input().split())
cnt = 0
for i in range(1, N+1):
    if a <= sum(list(map(int, str(i)))) <= b:
        cnt += i
print(cnt)

### FIXED CODE ###

n, a, b = map(int, input().split())
cnt = 0
for i in range(1, n+1):
    if a <= sum(list(map(int, list(str(i))))) <= b:
        cnt += i
print(cnt)
s = str(input())
a = s.split('/')
if a[1]<=2019 and a[1] <=4 and a[2]<=30:
    print('Heisei')
else:
    print('TBD')

### FIXED CODE ###

s = str(input())
a = list(map(int,s.split('/')))
if a[1]<=2019 and a[1] <=4 and a[2]<=30:
    print('Heisei')
else:
    print('TBD')
n, m, c = map(int, input().split())
b = [int(i) for i in input().split()]
a = [[int(input()) for _ in range(m)] for _ in range(n)]
ans = 0
ctn = 0
for j in range(n):
    for k in range(m):
        ctn += b[n] * a[n][m]
    if ctn - c > 0:
        ans += 0
    ctn = 0
print(ans)

### FIXED CODE ###

n, m, c = map(int, input().split())
b = [int(i) for i in input().split()]
a = [[int(j) for j in input().split()] for _ in range(n)]
ans = 0
for k in range(n):
    ct = c
    for l in range(m):
        ct += a[k][l] * b[l]
    if ct > 0:
        ans += 1
    ct = 0
print(ans)
c = input()
if c = "a" or c = "i" or c = "u" or c = "e", c = "o":
	print("vowel")
    
else:
	print("consonant")

### FIXED CODE ###

c = input()
if c == "a" or c == "i" or c == "u" or c == "e" or c == "o":
	print("vowel")
    
else:
	print("consonant")
from functools import lru_cache

def main():
    N=int(input())
    A=[int(_) for _ in input().split()]

    @lru_cache(None)
    def dp(i,k):
        if k<=0:
            return 0
        tmp=N-i
        if k>(tmp//2)+(tmp%2):
            return -float('inf')
        return max(A[i]+dp(i+2,k-1),dp(i+1,k))
    print(dp(0,N//2))

main()

### FIXED CODE ###

def main():
    N=int(input())
    A=[int(_) for _ in input().split()]
    dp=[[0,0,0] for _ in range(N//2+1)]
    for i in range(N//2):
        dp[i+1][0]=dp[i][0]+A[i*2]
        dp[i+1][1]=max(dp[i][1],dp[i][0])+A[i*2+1]
        if N%2:
            dp[i+1][2]=max(dp[i][2],dp[i][1],dp[i][0])+A[i*2+2]
    if N%2:
        print(max(dp[-1]))
    else:
        print(max(dp[-1][:2]))

main()
n=int(input())
a=n//1000
n=n%1000
b=n//100
n=n%100
c=n//10
d=n%10
if b==c and (a==b or c==d):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

n=int(input())
a=n//1000
n=n%1000
b=n//100
n=n%100
c=n//10
d=n%10
if b==c and (a==b or c==d):
  print("Yes")
else:
  print("No")
N, K = map(int, input().split())
h1, h2 = map(int, input().split())
l = []
l.append(h1)
l.append(h2)
for i in range(N-2):
    h = int(input())
    global l
    if len(l) < K:
        l.append(h)
    elif len(l) >= K:
        if h > min(l):
            l[l.index(min(l))] = h
        if h < max(l):
            l[l.index(max(l))] = h
print(max(l) - min(l))

### FIXED CODE ###

D = int(input())
if D == 25:
    print('Christmas')
elif D == 24:
    print('Christmas Eve')
elif D == 23:
    print('Christmas Eve Eve')
elif D == 22:
    print('Christmas Eve Eve Eve')
60 88 34
92 41 43
65 73 48
10
60
43
88
11
48
73
65
41
92
34

### FIXED CODE ###

row1 = input().split()
row2 = input().split()
row3 = input().split()

n = int(input())
nums = [input() for i in range(n)]

rows = [row1, row2, row3]

for i in range(0, 3):
    rows += [[row1[i], row2[i], row3[i]]]

rows += [[row1[0], row2[1], row3[2]]]
rows += [[row1[2], row2[1], row3[0]]]

for row in rows:
    j = 0
    for num in nums:
        if num in row:
            j += 1
        if j == 3:
            print('Yes')
            exit()

print('No')
a,b=map(int,input().split())
3 5
print(a*b 2*a+2*b)

### FIXED CODE ###

a,b=map(int,input().split())
print(a*b,2*(a+b))
N = int(input())
A = tuple(map(int, input().split()))
print(max(A) - min(A)

### FIXED CODE ###

N = int(input())
A = tuple(map(int, input().split()))
print(max(A) - min(A))
N=int(input())
a=list(map(int,input().split()))
ans=[['']*30 for _ in range(N)]
i=29

while True:
    curbit=[aa%2 for aa in a]

    s=sum(curbit)
    if s==0:
        break

    if s%2==0:
        for j in range(N):
            ans[j][i]=str(curbit[j])
    else:
        for j in range(N):
            ans[j][i]=str(0 if curbit[j] else 1)


    a=[aa//2 for aa in a]
    i-=1

print(' '.join([str(int(''.join(aa),2)) for aa in ans]))

### FIXED CODE ###

N=int(input())
a=list(map(int,input().split()))
ans=[[0]*30 for _ in range(N)]

if sum(a)==0:
    print(' '.join(['0']*N))
    exit(0)

i=29

while i>=0:
    curbit=[aa%2 for aa in a]

    s=sum(curbit)

    if s%2==0:
        for j in range(N):
            ans[j][i]=curbit[j]
    else:
        for j in range(N):
            ans[j][i]=0 if curbit[j] else 1



    a=[aa//2 for aa in a]
    
    i-=1

print(' '.join([str(int(''.join([str(aaa) for aaa in aa]),2)) for aa in ans]))
input() = N
for i in range(10):
  if N==i**2:
    print("Yes")
  else:
    print("No")

### FIXED CODE ###

n=int(input())
for a in range(1,10):
  for b in range(1,10):
    if n==a*b:
      print("Yes")
      exit()
    
print("No")
_ = input()
num_list = input().split(" ")
num_list = list(map(lambda x:int(x), num_list))
 
shift_counter = 0
 
while(True):
  if sum(num_list) % 2 != 0:
    break
  
  num_list = [x / 2 for x in num_list]
  shift_counter += 1
 
print(shift_counter)

### FIXED CODE ###

string = input()

one_counter = 0
for s in string:
  if s =="1":
    one_counter += 1

print(one_counter)
x=int(input())
print X**3


### FIXED CODE ###

x=int(input())
print(x**3)