Harryxun/stf_run huggingface dataset:
nk = input().split()
n , k = int(nk[0]), int(nk[1])
a = [int(i) for i in input().split()]

t = 1
tl = [1]
ts = {1}


for i in range(len(a)):
    
    t = a[t-1]
    if t in ts:
        break
    else:
        tl.append(t)
        ts.add(t)

tl2 = tl[tl.index(t):len(tl)]
         
# print(tl)
# print(tl2)

ans = 0

if k <= len(tl):
    ans = tl[k]
else:
    k = k - len(tl)
    j = k % len(tl2)
    ans = tl2[j]

print(ans)

### FIXED CODE ###

nk = input().split()
n , k = int(nk[0]), int(nk[1])
a = [int(i) for i in input().split()]

t = 1
tl = [1]
ts = {1}


for i in range(len(a)):
    
    t = a[t-1]
    if t in ts:
        break
    else:
        tl.append(t)
        ts.add(t)

tl2 = tl[tl.index(t):len(tl)]
         
# print(tl)
# print(tl2)

ans = 0

if k < len(tl):
    ans = tl[k]
else:
    k = k - len(tl)
    j = k % len(tl2)
    ans = tl2[j]

print(ans)
import collections
N = int(input())
V = input().split(' ')

EVEN = V[0::2]
ODD = V[1::2]
EVEN_V = collections.Counter(EVEN)
ODD_V = collections.Counter(ODD)
if N == 2:
  print(0)
A = len(EVEN_V)
B = len(ODD_V)


if EVEN_V.most_common()[0][1] >= ODD_V.most_common()[0][1]:
  MAX_ELE = EVEN_V.most_common()[0][0]
  count_max =EVEN_V.most_common()[0][1]
  for i in range(B):
    if MAX_ELE != ODD_V.most_common()[i][0]:
      SECOND_ELE = ODD_V.most_common()[i][0]
      count_SEC = ODD_V.most_common()[i][1]
      break
    else:
      count_SEC = N/2
  
else:
  MAX_ELE = ODD_V.most_common()[0][0]
  count_max = ODD_V.most_common()[0][1]
  for i in range(A):
    if MAX_ELE != EVEN_V.most_common()[i][0]:
      SECOND_ELE =EVEN_V.most_common()[i][0]
      count_SEC = EVEN_V.most_common()[i][1]
      break
    else:
      count_SEC = N/2
print((N- int(count_max) - int(count_SEC)))


### FIXED CODE ###

N = str(input())

def reverse(N):
  Answer = ''
  for x in N:
    if x == '1':
      Answer += '9'
    else:
      Answer += '1'
  return Answer
print(reverse(N))
def max_honest(n_ppl, testimonies):
    formating_str = "{0:0" + str(n_ppl) + "b}"
    max = 0
    for i in range(1, 2**n_ppl + 1):
        current_val = formating_str.format(2**n_ppl - i)
        potential = True
        valid_testemonies = []
        for j in range(0, len(current_val)):
            if current_val[j] == "1":
                for k in range(0, len(testimonies[j])):
                    valid_testemonies.append(testimonies[j][k])
        for j in range(0, len(valid_testemonies)):
            if str(valid_testemonies[j][1]) != current_val[valid_testemonies[j][0] - 1]:
                potential = False
                break
        if potential:
            if current_val.count("1") > max:
                max = current_val.count("1")
    return max

testimonies = []
n_ppl = int(input())

for i in range(0, n_ppl):
    tests = []
    n_tests = int(input())
    for j in range(0, n_tests):
        test = input()
        test = (int(test[0]), int(test[2]))
        tests.append(test)
    testimonies.append(tests)
print(max_honest(n_ppl, testimonies))

### FIXED CODE ###

def max_honest(n_ppl, testimonies):
    formating_str = "{0:0" + str(n_ppl) + "b}"
    max = 0
    for i in range(1, 2**n_ppl + 1):
        current_val = formating_str.format(2**n_ppl - i)
        potential = True
        valid_testemonies = []
        for j in range(0, len(current_val)):
            if current_val[j] == "1":
                for k in range(0, len(testimonies[j])):
                    valid_testemonies.append(testimonies[j][k])
        for j in range(0, len(valid_testemonies)):
            if str(valid_testemonies[j][1]) != current_val[valid_testemonies[j][0] - 1]:
                potential = False
                break
        if potential:
            if current_val.count("1") > max:
                max = current_val.count("1")
    return max

testimonies = []
n_ppl = int(input())

for i in range(0, n_ppl):
    tests = []
    n_tests = int(input())
    for j in range(0, n_tests):
        test = input().split(" ")
        test = (int(test[0]), int(test[1]))
        tests.append(test)
    testimonies.append(tests)
    
print(max_honest(n_ppl, testimonies))
a, b, c = map(int, input().split())
if (b - a) = (c - b):
    print('YES')
else:
    print('NO')

### FIXED CODE ###

a, b, c = map(int, input().split())
if (b - a) == (c - b):
    print('YES')
else:
    print('NO')
a,b = int(input())
s = a-b*2
if s <= 0:
    print(0)
else:
    print(s)

### FIXED CODE ###

a,b = map(int,input().split())
s = a-b*2
if s <= 0:
    print(0)
else:
    print(s)
x, n = input().split(' ')
line = input()
if line == '':
    print(x)
    exit()

x = int(x)

alist = line.split(' ')
for i in range(int(n)):
    alist[i] = int(alist[i])
if not x in alist:
    print(x)
    exit()

blist = [i for i in range(1,101)]
bset = set(blist)
aset = set(alist)
cset = bset-aset
clist = list(cset)
clist.append(x)
clist.sort()

count = 0
for i,v in enumerate(alist):
    if v == int(x):
        count = i
if count == 0:
    print(alist[1])
elif count == 99:
    print(alist[-2])
else:
    minx = x - alist[count-1]
    maxx = alist[count+1]-x
    if minx > maxx:
        print(alist[count+1])
    else:
        print(alist[count-1])

### FIXED CODE ###

x, n = input().split(' ')
line = input()
if line == '':
    print(x)
    exit()

x = int(x)

alist = line.split(' ')
for i in range(int(n)):
    alist[i] = int(alist[i])
if not x in alist:
    print(x)
    exit()

blist = [i for i in range(0,102)]
bset = set(blist)
aset = set(alist)
cset = bset-aset
clist = list(cset)
clist.append(x)
clist.sort()

count = 0
for i,v in enumerate(clist):
    if v == x:
        count = i
if count == 0:
    print(clist[1])
elif count == len(clist)-1:
    print(clist[-2])
else:
    minx = x - clist[count-1]
    maxx = clist[count+1]-x
    if minx > maxx:
        print(clist[count+1])
    else:
        print(clist[count-1])
a,b,c,d=map(int,input().split())
import fractions
import math
nc=math.floor(b/c)-math.ceil(a/c)+1
nd=math.floor(b/d)-math.ceil(a/d)+1
min=c*d/fractions.gcd(c,d)
ncd=math.floor(b/min)-math.ceil(a/min)+1
print(b-a+1-(nc+nd-ncd))

### FIXED CODE ###

a=input()
cnt=0
for i in range(3):
    if a[i]==a[i+1]:
        cnt+=1
print("Good" if cnt==0 else "Bad")
N, M = map(int, input().split())
list_x = list(map(int, input().split()))
list_x.sort()
list_data = []
a = list_x[0]
for i,x in enumerate(list_x):
    if i != 0:
        diff = x - a
        a = x
        list_data.append(diff)
    else:
        pass
if len(list_data) != 0:
    for _ in range(N-1):
        list_data.remove(max(list_data))
    print(sum(list_data))
else:
    print(0)

### FIXED CODE ###

import numpy as np
N, M = map(int, input().split())
list_x = list(map(int, input().split()))
list_x.sort()
list_d = np.diff(list_x)
list_data = list_d.tolist()
if len(list_data) != 0:
    if N >= 2:
        list_data.sort()
        del list_data[-(N-1):]
        print(sum(list_data))
    if N == 1:
        print(sum(list_data))
else:
    print(0)
n = int(input())
lst = [int(input()) for x in range(n)]
if n==1:
    print(1)
    break
else:
    split_info = [0] + [i for i in range(1, n) if lst[i-1]<=lst[i]] + [n-1]
    if len(split_info)==2:
        print(n)
        break
    result = [len(lst[split_info[i]:split_info[i+1]]) for i in range(len(split_info)-1)]
print(max(result))

### FIXED CODE ###

n = int(input())
print(len(set([int(input()) for x in range(n)])))
n=input()
a=map(int,raw_input().split())
r=0
for i in range(1<<n):
 b=[a[j]*((i>>j&1)*2-1)%24 for j in range(n)]+[0]
 s=24
 for j in range(n):
  for k in range(j+1,n+1):s=min(s,(b[j]-b[k])%24,(b[k]-b[j])%24)
 r=max(r,s)
print r

### FIXED CODE ###

n=input()
a=sorted(map(int,raw_input().split()))
r=0
b=[0]+[a[j]*(-1)**j%24 for j in range(n)]
s=24
for j in range(n):
 for k in range(j+1,n+1):s=min(s,(b[j]-b[k])%24,(b[k]-b[j])%24)
r=max(r,s)
print r
def prepare(n,arr):
    nodeArr = [[] for i in range(n)]
    for ar in arr:
        nodeArr[ar[0]-1].append([ar[1]-1,ar[2]])
        nodeArr[ar[1]-1].append([ar[0]-1,ar[2]])
    return nodeArr

def dfs(parent,currentNode,distance):

    if len(nodeArr[currentNode]) == 1:
        if currentNode != 0:
            # 末点
            res[currentNode] = distance
            return

    for next in nodeArr[currentNode]:
        nextNode = next[0]
        nextNodeDistance = next[1]
        if nextNode == parent:
            continue
        dfs(currentNode,nextNode,distance + nextNodeDistance)
    res[currentNode] = distance


n = int(input())

arr = []

for i in range(n-1):
    arr.append([int(s) for s in input().split(" ")])

nodeArr = prepare(n, arr)


if n == 1:
    print(1)
else:
    res = [-1 for i in range(n)]

    dfs(-1,0,0)

    result = [(re % 2) for re in res]

    for re in res:
        print(re % 2)



### FIXED CODE ###

import sys
sys.setrecursionlimit(20000000)
def prepare(n,arr):
    nodeArr = [[] for i in range(n)]
    for ar in arr:
        nodeArr[ar[0]-1].append([ar[1]-1,ar[2]])
        nodeArr[ar[1]-1].append([ar[0]-1,ar[2]])
    return nodeArr

def dfs(currentNode,distance):
    res[currentNode] = distance
    for next in nodeArr[currentNode]:
        nextNode = next[0]
        nextNodeDistance = next[1]
        if res[nextNode] == -1:
            dfs(nextNode,distance + nextNodeDistance)




n = int(input())

arr = []

for i in range(n-1):
    arr.append([int(s) for s in input().split(" ")])

nodeArr = prepare(n, arr)


if n == 1:
    print(1)
else:
    res = [-1 for i in range(n)]

    dfs(0,0)

    result = [(re % 2) for re in res]

    for re in res:
        print(re % 2)
n,k=map(int,input().split())
CONST=10**9+7
path={i:list() for i in range(n)}
for i in range(n-1):
  a,b=map(int,input().split())
  path[a-1].append(b-1)
  path[b-1].append(a-1)
used=[0]*n
used[0]=1
  
def bfs(pos, parent):
  res=k-parent
  deg=2 if parent else 1
  for next in path[pos]:
    if used[next]:
      continue
    #print(pos,next,res)
    used[next]=1
    res *= bfs(next,deg)
    res %= CONST
    deg += 1
  return res%CONST
    
print(bfs(0, 0))

### FIXED CODE ###

import sys
sys.setrecursionlimit(10000000)
n,k=map(int,input().split())
CONST=10**9+7
path={i:list() for i in range(n)}
for i in range(n-1):
  a,b=map(int,input().split())
  path[a-1].append(b-1)
  path[b-1].append(a-1)
used=[0]*n
used[0]=1
  
def bfs(pos, parent):
  res=k-parent
  if parent>0:
    deg=2
  else:
    deg=1
  for nex in path[pos]:
    if used[nex]:
      continue
    used[nex]=1
    res *= bfs(nex,deg)
    res = res%CONST
    deg += 1
  return res%CONST
    
print(bfs(0, 0))
import math

inf = 10**9+7

def combinations_count(n, r):
    return math.factorial(n) / (math.factorial(n - r) * math.factorial(r))

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

red = n - k
for i in range(1,k+1):
    if i == 1:
        print(red + 1 -i)
    else:
        print(combinations_count(red+1, i)*2**(k-i)%inf)

### FIXED CODE ###

import math

inf = 10**9+7

def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

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

red = n - k
for i in range(1,k+1):
    if red+1 >= i:
        print(combinations_count(red+1, i)*combinations_count(k-1, i-1)%inf)
    else:
        print(0)
n,k=map(int,input().split())
import math
print(1+math.floor(math.log(n,k)))

### FIXED CODE ###

n,r=map(int,input().split())
if n>=10:
    print(r)
else:
    print(r+100*(10-n))
from collections import Counter

N = int(input())
S = input()
P = 10**9 + 7

dic = Counter(S)
rlt = 1

for k in dic:
  rlt = rlr*(dic[k]+1) % P
  
print(rlt-1)

### FIXED CODE ###

from collections import Counter

N = int(input())
S = input()
P = 10**9 + 7

dic = Counter(S)
rlt = 1

for k in dic:
  rlt = rlt*(dic[k]+1) % P
  
print(rlt-1)
N,A,B,C,D = map(int, input().split())
s = input()
index = [(n+1) for n, v in enumerate(s) if s[n:n+3] == "..."]

if s.count("##")>=1:
    print("No")
    exit()

if C < D:
    print("Yes")

elif C > D:
    if len(index)>=1:
        for i in index:
            if A <= i and B <= i+1 and i+2<=C and i+1<=D:
                print("Yes")
                exit()
        priny("No")
    else:
        print("No")


### FIXED CODE ###

N,A,B,C,D = map(int, input().split())
s = input()
index = [(n+1) for n, v in enumerate(s) if s[n:n+3] == "..."]

if C < D:
    if "##" in s[A-1:D]:
        print("No")
    else:
        print("Yes")

if C > D:
    if "##" in s[A-1:C]:
        print("No")
    else:
        if len(index)>=1:
            for i in index:
                if B <= i+1 <= D:
                    print("Yes")
                    exit()
            print("No")
        else:
            print("No")
n,k = map(int,input().split())
a,p = [1],[1]
for i in range(n):
  a.append(a[i]*2+3)
  p.append(p[i]*2+1)
def f(n,k):
  if k == 0:
    return 0
  if n == 0:
    if k == 0:
      return 0
    else:
      return 1
  elif k <= a[n-1]+1:
    return f(n-1,k-1)
  elif k == p[n]:
    return p[n-1]+1
  elif k <= a[n]*2+3:
    return p[n-1]+1+f(n-1,k-2-a[n-1])
print(f(n,k))



### FIXED CODE ###

n,k = map(int,input().split())
a,p = [1],[1]
for i in range(n):
  a.append(a[i]*2+3)
  p.append(p[i]*2+1)
def f(n,k):
  if n == 0:
    if k == 0:
      return 0
    else:
      return 1
  if k == 0:
    return 0
  elif k <= a[n-1]+1:
    return f(n-1,k-1)
  else:
    return p[n-1]+1+f(n-1,k-2-a[n-1])
print(f(n,k))
a,b=int(input())

if(a==1):
  print(max(0,b-2))
elif(b==1):
  print(max(0,a-2))
else:
  print((a-2)*(b-2))

### FIXED CODE ###

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

if(a==1 and b==1):
  print(1)
elif(a==1):
  print(max(0,b-2))
elif(b==1):
  print(max(0,a-2))
else:
  print((a-2)*(b-2))
import math
import itertools
import heapq
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque


# d = defaultdict(lambda: 0)
# setrecursionlimit(10**7)
# inf = float("inf")


##### stdin ####
def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_IL(): return LM(int,stdin)

##### tools #####
def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))



##### main #####

def gcd(a, b):
	while b:
		a, b = b, a % b
	return a


def main():
	n = I()
	a = LI()
	b = LI()

	pos = 0
	neg = 0
	


	for i in range(n):
		diff = a[i]-b[i]

		if diff>0:
			pos += abs(diff)
		else:
			neg += abs(diff)

	g = gcd(pos,neg)
	if 2*(pos//g) == neg//g:
		print("Yes")
	else:
		print("No")


if __name__ == '__main__':
  main()

### FIXED CODE ###

import math
import itertools
import heapq
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect, bisect_left, bisect_right
from collections import defaultdict, deque


# d = defaultdict(lambda: 0)
# setrecursionlimit(10**7)
# inf = float("inf")


##### stdin ####
def LM(t, r): return list(map(t, r))
def R(): return stdin.readline()
def RS(): return R().split()
def I(): return int(R())
def F(): return float(R())
def LI(): return LM(int,RS())
def LF(): return LM(float,RS())
def ONE_SL(): return list(input())
def ONE_IL(): return LM(int, ONE_SL())
def ALL_IL(): return LM(int,stdin)

##### tools #####
def ap(f): return f.append
def pll(li): print('\n'.join(LM(str,li)))
def pljoin(li, s): print(s.join(li))



##### main #####
def main():
	n = I()
	x = 0; y = 0
	
	for a,b in zip(LI(),LI()):
		if a > b:
			x += a-b
		else:
			y += (b-a)//2

	print('Yes' if y >= x else "No")

if __name__ == '__main__':
  main()
import sys
n,q = map(int,sys.stdin.readline().rstrip().split())
t = {}
for i in range(n-1):
    a,b = map(int,sys.stdin.readline().rstrip().split())
    if a in t:
        t[a].append(b)
    else:
        t[a] = [b]
ans = [0 for i in range(n)]

def search(j):
    if j in t:
        l = [j]
        for k in t[j]:
            l = l + search(k)
    else:
        l = [j]
    return l

for i in range(q):
    p,x = map(int,sys.stdin.readline().rstrip().split())
    s = search(p)
    for i in s:
        ans[i-1] += x
print(" ".join(map(str,ans)))

### FIXED CODE ###

import sys
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n,q = map(int,input().split())
tree = [[] for i in range(n)]
ans = [0]*n
for i in range(n-1):
    a,b = map(lambda x:int(x)-1,input().split())
    tree[a].append(b)
    tree[b].append(a)

for i in range(q):
    p,x = map(int, input().split())
    ans[p - 1] += x

d = deque([[0,0]])
c = [False]*n
c[0] = True
while d:
    x,s = d.pop()
    s += ans[x]
    ans[x] = s
    for e in tree[x]:
        if not c[e]:
            c[e] = True
            d.append([e,s])

print(*ans)
a=list(int(input))
i=0
for j in range(1,4):
  if a[i]== a[j]:
    print('Bad')
    break
  elif a[i]!= a[j] and j == 4:
    print('Good')
  i += 1
  

### FIXED CODE ###

a=list(input())
i=0
for j in range(1,4):
  if a[i]== a[j]:
    print('Bad')
    break
  elif a[i]!= a[j] and j == 3:
    print('Good')
  i += 1
def f():
 for e in iter(input,'0'):
  a=[list(map(int,input().split()))for _ in[0]*int(e)]
  u,v=a[0]
  b=[tuple(map(int,input().split()))for _ in[0]*int(input())]
  for x,y in b:
   for s,t in a[1:]:
    if(x+s-u,y+t-v)not in b:return print(x-sx,y-sy)
f()


### FIXED CODE ###

for e in iter(input,'0'):
 a=[[*map(int,input().split())]for _ in[0]*int(e)]
 s,t=min(a)
 b={tuple(map(int,input().split()))for _ in[0]*int(input())}
 m=max(b)[0]-max(a)[0]+s
 for x,y in b:
  if x<=m:
   for u,v in a:
    if(x+u-s,y+v-t)not in b:break
   else:print(x-s,y-t);break
a, b, c, d = [int(temp) for temp in input().split()]
from math import sqrt
dis = sqrt((c - a) ** 2 + (d - b) ** 2)
print('%0.5f'%dis)

### FIXED CODE ###

a, b, c, d = [float(temp) for temp in input().split()]
from math import sqrt
dis = sqrt((c - a) ** 2 + (d - b) ** 2)
print('%0.5f'%dis)
X, N = map(int, input().split())
P = list(map(int, input().split()))
Q = [i for i in range(-100, 101) if i not in P]

c = 0
R = 1000
if N == 0:
    print(X)
else:
    while True:
        if R <= abs(X-Q[c]):
            break
        else: 
            R = abs(X-Q[c])
            c += 1
    print(Q[c-1])

### FIXED CODE ###

X, N = map(int, input().split())
if N>0:
  P = list(map(int, input().split()))
else:
  P = []
i = 0
while True:
  if X-i not in P:
    print(X-i)
    break
  if X+i not in P:
    print(X+i)
    break
  i += 1
s = int(input())

for i in range(1,4):
  if s[i-1]==s[i]:
    print("Bad")
    exit()
print("Good")
  

### FIXED CODE ###

s =input()
 
for i in range(1,4):
  if s[i-1]==s[i]:
    print("Bad")
    exit()
print("Good")
a,b = (int(x) for x in input().split())
cnt = 0
for i in range(a,b+1):
    if str(i) == str(i)[::-1]:
        cnt += 1

print(cnt)


### FIXED CODE ###

a,b = input().split(" ")
a = int(a)
b = int(b)

if a < 10000 or b > 99999:
    sys.exit(1)

cnt = 0
for i in range(a,b+1):
    if str(i) == str(i)[::-1]:
        cnt += 1

print(cnt)
# coding: utf8

if __name__ == "__main__":
    x = int(input())
    if x == 3 or x == 5 or == 7:
        print("YES")
    else:
        print("NO")

### FIXED CODE ###

# coding: utf8

if __name__ == "__main__":
    x = int(input())
    if x == 3 or x == 5 or x == 7:
        print("YES")
    else:
        print("NO")
import numpy as np

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

ans = 0

for i in range(N):
	ans = (ans +  A[i] * numpy.sum(A[i+1:N])) % (10**9+7)

print(ans)

### FIXED CODE ###

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

DIV = 10**9+7
ans = 0
Asum = sum(A)
Asum_sq = Asum**2

for i in range(N):
	ans += A[i]**2

res = (Asum_sq-ans)//2
print(res%DIV)
from collections import deque
n=int(input())
l=[0]*n
d={}
for i in range(n-1):
    a,b,c=map(int,input().split())
    a-=1
    b-=1
    if a in d:
        d[a].add((b,c))
    else:
        d[a]={(b,c)}
    if b in d:
        d[b].add((a,c))
    else:
        d[b]={(a,c)}
q,k=map(int,input().split())
k-=1
p=deque([k])
while len(p):
    w=p.popleft()
    for i in d[w]:
        if (l[i[0]]==0 and i[0]!=k) or (l[i[0]]!=0 and l[i[0]]>l[w]+l[i[1]]):
            print(i)
            l[i[0]]=l[w]+i[1]
            p.append(i[0])

for i in range(q):
    x,y=map(int,input().split())
    print(l[x-1]+l[y-1])

### FIXED CODE ###

from collections import deque
n=int(input())
l=[0]*n
d={}
for i in range(n-1):
    a,b,c=map(int,input().split())
    a-=1
    b-=1
    if a in d:
        d[a].add((b,c))
    else:
        d[a]={(b,c)}
    if b in d:
        d[b].add((a,c))
    else:
        d[b]={(a,c)}
q,k=map(int,input().split())
k-=1
p=deque([k])
while len(p):
    w=p.popleft()
    for i in d[w]:
        if (l[i[0]]==0 and i[0]!=k) or (l[i[0]]!=0 and l[i[0]]>l[w]+i[1]):
            l[i[0]]=l[w]+i[1]
            p.append(i[0])

for i in range(q):
    x,y=map(int,input().split())
    print(l[x-1]+l[y-1])
k = int(input())
s = ''
for i in range(K):
  s += 'ACL'
print(s)

### FIXED CODE ###

k = int(input())
s = ''
for i in range(k):
  s += 'ACL'
print(s)
n = int(input())
A = list(map(int, input().split()))
if len(A) % 2:
	print(*A[-1::-2], *A[1::2])
else:
	print(*A[-1::-2], *A[::2])

### FIXED CODE ###

n = int(input())
A = list(map(int, input().split()))
if len(A) % 2:
	print(*(A[-1::-2] + A[1::2]))
else:
	print(*(A[-1::-2] + A[::2]))
import numpy as np

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

As = np.array(list(map(int,input().split())))
Bs = np.array(list(map(int,input().split())))

As_selected = []
Bs_selected = []

answer = 0

for i in range(N+1):
    if(As[0:i].sum() <= K):
         As_selected.append(As[0:i].sum())
    else:
        break
for i in range(M+1):
    if(Bs[0:i].sum() <= K):
         Bs_selected.append(Bs[0:i].sum())
    else:
        break

answer = 0

for i in np.arange(len(As_selected))+1:
    for j in np.arange(len(Bs_selected))+1:
        if(As_selected[-i] + Bs_selected[-j] <= K):
            answer = max(len(As_selected)+len(Bs_selected) -i - j, answer)
            break

print(answer)

### FIXED CODE ###


a = int(input())

print(a + a**2 + a**3)
N = input()

ab = input( )

ab = ab.split()

if 0 in ab:
    print(0)
else:
    SUM = 1
    for i in range(int(N)):
        SUM = SUM * int(ab[i])

    if (int(SUM) < 10 ** 18):
        print(SUM)
    else:
        print(-1)


### FIXED CODE ###

ab = input( )

ab = ab.split()
print(int(ab[1])*int(ab[0]))
K = int(input()) 
S = input()

if len(S) > K:
    a = S[:K]  + '...'

print(a)

### FIXED CODE ###

K = int(input()) 
S = input()

if len(S) > K:
    S = S[:K]  + '...'

print(S)
x = int(input())
print(S//3600,(S%3600)//60,S//60,sep=':')


### FIXED CODE ###

S = int(input())
print(S//3600,(S%3600)//60,S%60,sep=":")
import numpy as np
N = int(input())
a_s = input().split()
for i in range(N):
    a_s[i] = int(a_s[i])
a_s = np.array(a_s)

a_unique = np.unique(a_s)
a_counts = []
for i,a in enumerate(a_unique):
    a_counts.append(np.sum(a_s==a))
a_counts = np.array(a_counts)

ans = 0
for i in range(len(a_unique)):
    val = a_counts[i]
    if (i>0)&(a_unique[i-1]+1==a_unique[i]):
        val += a_counts[i-1]
            
    if (i<len(a_unique)-1)&(a_unique[i+1]-1==a_unique[i]):
        val += a_counts[i+1]
    
    if val > ans:
        ans = val
        
    if ans >= sum(a_counts[i:]):
        break
        
print(ans)

### FIXED CODE ###

from collections import Counter

N = int(input())
a_s = input().split()
a_s = [int(a_s[i]) for i in range(N)]

c = Counter(a_s)
c = sorted(c.items(), key=lambda x:x[0])
a_unique, a_counts = zip(*c)

ans = 0
for i,a in enumerate(a_unique):
    val = a_counts[i]
    if (i>0):
        if (a_unique[i-1]+1==a):
            val += a_counts[i-1]
            
    if (i<len(a_unique)-1):
        if (a_unique[i+1]-1==a):
            val += a_counts[i+1]
    
    if val > ans:
        ans = val
        
print(ans)
#!/usr/bin/env python
# -*- coding: utf-8 -*-

N = input()
m,a,r,c,h = 0
for i in range(N):
	S = raw_input()
	if S[:1] == "M":
		m += 1
	elif S[:1] == "A":
		a += 1
	elif S[:1] == "R":
		r += 1
	elif S[:1] == "C":
		c += 1
	elif S[:1] == "H":
		h += 1
print m*a*r+m*a*c+m*a*c+m*a*h+m*r*c+m*r*h+m*c*h+m*c*h+a*r*c+a*r*h+a*c*h+r*c*h	

### FIXED CODE ###

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

X = input()
print X//3