Harryxun/stf_run huggingface dataset:
n,k=map(int,input().split())
A=list(map(int,input().split()))
cc=1
for j in range(k):
  cc*=A[j]

for i in range(k,n):
  pp=A[i]*cc//A[i-k]
  if pp>cc:print('Yes')
  else:print('No')
  
  cc=pp

### FIXED CODE ###

x=int(input())

if x<600:
  print(8)
elif x<800:
  print(7)
elif x<1000:print(6)
elif x<1200:print(5)
elif x<1400:print(4)
elif x<1600:print(3)
elif x<1800:print(2)
else:print(1)
N,M = map(int,input().split())
H = input().split()
good = [1]*N
import collections

for i in range(M):
  a,b = map(int,input().split())
  if int(H[a-1]) >= int(H[b-1]):
    good[int(H[b-1])] = 0
  else:
    good[int(H[a-1])] = 0  
    
c = collections.Counter(good)
print(c[1])

### FIXED CODE ###

N,M = map(int,input().split())
H = input().split()
good = [1]*N
import collections

for i in range(M):
  a,b = map(int,input().split())
  if int(H[a-1]) > int(H[b-1]):
    good[b-1] = 0
  elif int(H[a-1]) < int(H[b-1]):
    good[a-1] = 0
  else:
    good[a-1] = 0
    good[b-1] = 0
    
c = collections.Counter(good)
print(c[1])
import sys
from collections import Counter

def ii(): return int(sys.stdin.readline())
def li(): return list(map(int, sys.stdin.readline().split()))

if __name__ == "__main__":
    n = ii()
    a = li()
    c = Counter(a)
    del_list = []
    for k, v in c.items():
        if v >= 2:
            del_list.append(k)
    for k in del_list:
        del c[k]
    a = sorted(c.keys())
    max_a = a[-1]
    if len(a) == 0:
        print(0)
        exit()
    b = [True] * (max_a + 1)
    def sived(x):
        for not_ans in range(x+x, max_a + 1, x):
            b[not_ans] = False
    for i in a:
        if b[i]:
            sived(i)
    ans = 0
    for i in a:
        if b[i]:
            ans += 1
    print(ans)


### FIXED CODE ###

import sys
from collections import Counter

def ii(): return int(sys.stdin.readline())
def li(): return list(map(int, sys.stdin.readline().split()))

if __name__ == "__main__":
    n = ii()
    a = li()
    a = sorted(a)
    a_max = a[-1]
    sive = [True] * (a_max + 1)

    def sived(x):
        for non_ans in range(x, a_max+1, x):
            sive[non_ans] = False
    ans = 0
    for i in range(len(a)-1):
        if sive[a[i]]:
            sived(a[i])
            if a[i] != a[i+1]:
                ans += 1
    if sive[a_max]:
        ans += 1
    print(ans)
import numpy as np
def XOR(X):
	X=np.array(X)
	out=0
	i=0
	while(max(X)>0):
		out+=(np.sum(X%2)%2)*(2**i)
		X=X//2
		i+=1

	return out



A,B=input().split(" ")
A=int(A)
B=int(B)


X=range(A,B+1)
print(XOR(X))







### FIXED CODE ###

A,B=input().split(" ")
A=int(A)
B=int(B)



if(A%2==1):
	A_=A+1
else:
	A_=A
if(B%2==0):
	B_=B-1
else:
	B_=B

out=((B_-A_+1)//2)%2
#import numpy as np
if(A%2==1):
	out^=A
if(B%2==0):
	out^=B
print(out)
n = input()
s = list(map(int,input().split()))
c = 0
for i in s:
  if s % 2 == 1:
    c+=1
if c % 2 == 1:
  print("NO")
else:
  print("YES")

### FIXED CODE ###

n = input()
s = list(map(int,input().split()))
c = 0
for i in s:
    if i % 2 == 1:
        c+=1
if c % 2 == 1:
    print("NO")
else:
    print("YES")
import sys
n=int(input())
a=list(map(int,input().split()))
j=0
cnt=0
if n<=2:
    sys.exit("Yes")
for i in range(1,n):
    if 0<=a[i]-a[j]:
        #print(i,j)
        j=i
        continue
    else:
        #print(i,j,"else")
        cnt+=1
        j=i
        if cnt==2:
            break
        else:
            continue
        
if cnt<=1:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

N = int(input())
H = list(map(int, input().split()))
v = -1
for h in H:
    if v > h:
        if v != h+1:
            print("No")
            exit()
        else:
            v = h+1
    else:
        v = h
print("Yes")
a,b,c=map(int(input().split())
print(a*b/2)

### FIXED CODE ###

a,b,c=map(int,input().split())
print(a*b//2)
INF = float("inf")
n = int(input())
A = [0]
for i, a in enumerate(sys.stdin):
    a = list(map, a.split())
    if i == 0:
        A.extend(a)
    else:
        A.append(a[1])
C = [[INF] * (n + 1) for _ in range(n + 1)]
for i in range(n + 1):
    C[i][i] = 0
for j in range(1, n):
    for i in range(1, n - j + 1):
        for k in range(i + 1, i + j + 1):
            cost = C[i][k - 1] + C[k][i + j] + A[i] * A[k] * A[i + j + 1]
            if cost < C[i][i + j]:
                C[i][i + j] = cost
print(C[1][n])



### FIXED CODE ###

import sys
INF = float("inf")
n = int(input())
m = [[0] * (n + 1) for _ in range(n + 1)]
li = [list(map(int, a.split())) for a in sys.stdin]
z = (li[0][0], ) + list(zip(*li))[1]
for l in range(1, n):
    for i in range(1, n - l + 1):
        j = i + l
        m[i][j] = INF
        for k in range(i, j):
            m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + z[i - 1] * z[k] * z[j])
print(m[1][n])
S = input()
List = [input() for i in range(1)]
T = List[0]

Slst = list(S)
Tlst = list(T)
M = 0

for x in range(3):
    if Slst[x] == Tlst[x]:
        M += 1
print(M)


### FIXED CODE ###

lst = [int(x) for x in input().split()]
A = lst[0]
B = lst[1]

if B >= 2:
    m = 0
    while (A-1) * m + 1 < B:
        m += 1
    print(m)

if B == 1:
    print(0)
L = int(input())
N = math.ceil(math.log2(L))

M = N*2-2
add_path = []
for i in range(1,N)[::-1]:
    if L-2**(i-1) >= 2**(N-1):
        add_path.append([i, L-2**(i-1)]); L -= 2**(i-1)
print(N, M+len(add_path))
for i in range(1,N):
    print(i, i+1, 0)
    print(i, i+1, 2**(i-1))
for i in add_path:
    print(i[0], N, i[1])

### FIXED CODE ###

l=int(input())
for i in range(21):
  if 2 ** i > l:
    n = i
    break

m = (n - 1) * 2
  
s = l -  2 ** (n - 1)
value = 2 ** (n - 1)

path_add = [0 for i in range(n - 1)]
path_add_value = [0 for i in range(n - 1)]

for i in range(n - 1):
  if s >= 2 ** (n - 2 - i) :
    s -= 2 ** (n - 2 - i)
    path_add[-(i + 1)] = 1
    path_add_value[-(i + 1)] = value
    value += 2 ** (n - 2 - i)
  
#print(path_add)
#print(path_add_value)
#print(s)  
  
print(n, m + sum(path_add))
for i in range(n - 1):
  print(i + 1, i + 2, 0)
  print(i + 1, i + 2, 2 ** i)
  
for i in range(n - 1):
  if path_add[i] == 1:
    print(i + 1, n, path_add_value[i])
#!/usr/bin/env python3
from decimal import Decimal
a, b = input().split()
a = Decimal(int(a))
b = Decimal(b)
print(int(a * b))

### FIXED CODE ###

#!/usr/bin/env python3
n = int(input()) 
A = list(map(int, input().split()))
b = 1
i = 10**18
A = sorted(A)
for a in A:
  if b > i:
    break
  b *= a
print(-1 if b > i else b)
def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


def solve():
    A, B, C, D = read_ints()
    return max(A*B, C*D)


if __name__ == '__main__':
    print(solve())


### FIXED CODE ###



def read_int():
    return int(input().strip())


def read_ints():
    return list(map(int, input().strip().split(' ')))


def solve():
    x = read_int()
    if x < 1200:
        return 'ABC'
    return 'ARC'


if __name__ == '__main__':
    print(solve())
A,B = map(int,input().rstrip().split())
if A == B:
    print(A*A)
else:
    print(max(A,B) + (max(A,B) - 1)

### FIXED CODE ###

A,B = map(int,input().rstrip().split())

X = max(A,B)
if A == B:
    G = X * 2
else:
    Y = max(A,B) - 1
    G = X + Y
print(G)
import itertools

H, W = [int(_) for _ in input().split()]
A = [[_ for _ in input()] for _ in range(H)]
D = []
S = []
for x, y in itertools.product(range(H), range(W)):
    if A[x][y] == '.':
        D += [[x, y]]
    else:
        S += [[x, y]]

print(max(min([abs(X - x) + abs(Y - y) for x, y in S]) for X, Y in D))


### FIXED CODE ###

import itertools
from collections import deque

H, W = [int(_) for _ in input().split()]
A = [list(input()) for _ in range(H)]
Q = deque([])
for i, j in itertools.product(range(H), range(W)):
    if A[i][j] == '#':
        Q += [[i, j, 0]]
while Q:
    i, j, d = Q.popleft()
    for ni, nj in [[i - 1, j], [i + 1, j], [i, j - 1], [i, j + 1]]:
        if 0 <= ni < H and 0 <= nj < W and A[ni][nj] == '.':
            A[ni][nj] = '#'
            Q += [[ni, nj, d + 1]]
print(d)
N = int(input())
  2 V=list(map(int,input().split()))
  3 C=list(map(int,input().split()))
  4 output = 0
  5 for i in range(N):
  6     if V[i]-C[i] >= 0:
  7         output +=V[i]-C[i]
  8
  9 print(output)

### FIXED CODE ###

N = int(input())
V=list(map(int,input().split()))
C=list(map(int,input().split()))
output = 0
for i in range(N):
    if V[i]-C[i] >= 0:
        output +=V[i]-C[i]

print(output)
n,k,x,y=map(int, input().split())
sum_n=x*k+y*(n-k)
print(sum_n)


### FIXED CODE ###

n=int(input())
k=int(input())
x=int(input())
y=int(input())
print(min(n,k)*x+max(n-k,0)*y)
s = "input()"
if s[0] = 7:
  print("Yes")
elif s[1] = 7:
  print("Yes")
elif s[2] = 7:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

s = str(input())
if s[0] is "7":
  print("Yes")
elif s[1] is "7":
  print("Yes")
elif s[2] is "7":
  print("Yes")
else:
  print("No")
input();s=map(int,input().split());print('YNeos'[sum(s)-max(s)*2<1::2])


### FIXED CODE ###

print((lambda l:['No','Yes'][sum(l[:-1])>l[-1]])(sorted(list(map(int,input().split()+input().split()))[1:])))
s = input()
l = []
for t in s:
  if t == '0' or t == '1':
    l.append(t)
  elif t == 'B':
    l.pop()
for r in l:
  print(r, end='')

### FIXED CODE ###

s = input()
l = []
for t in s:
  if t == '0' or t == '1':
    l.append(t)
  elif t == 'B':
    if l != []:
      l.pop()
for r in l:
  print(r, end='')
def round_up_mean(a,b):
  ans = -(-(a+b)//2)
  print(ans)


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

### FIXED CODE ###

#import math
def round_up_mean(a,b):
#  ans = math.ceil((a+b)/2)
#  print(ans)
  ans = -(-(a+b)//2)
  print(ans)

a, b = map(int, input().split(" "))
round_up_mean(a, b)
N,M = map(int,input().split())
print(1900*M + 100*(N-M))*2**M

### FIXED CODE ###

N,M = map(int,input().split())
a = 1900*M + 100*(N-M)
b = 2**M
print(a*b)
import math

N = int(input())

for i in reversed(range(int(math.sqrt(N)))):
    if N % i == 0:
        print(i + N//i - 2)
        exit()

### FIXED CODE ###

import math

N = int(input())

for i in reversed(range(1, int(math.sqrt(N)) +1  )):
    if N % i == 0:
        print(i + N//i - 2)
        break
N, M = list(map(int, input().split()))


class UnionFind():
    def __init__(self, n):
        self.rank = [1 for _ in range(n)]
        self.parent = [i for i in range(n)]

    def union(self, i, j):
        i = self.root(i)
        j = self.root(j)
        if i == j:
            return
        if self.rank[i] < self.rank[j]:
            self.parent[i] = j
        else:
            if self.rank[i] == self.rank[j]:
                self.rank[j] += 1
            self.parent[j] = i

    def same(self, i, j):
        return self.root(i) == self.root(j)

    def root(self, i):
        if self.parent[i] != i:
            self.parent[i] = self.root(self.parent[i])
        return self.parent[i]


uf = UnionFind(N)

for _ in range(M):
    X, Y, _ = list(map(int, input().split()))
    uf.union(X-1, Y-1)

ans = 0

for i in range(N):
    if uf.root(i) == i:
        ans += 1

print(ans)


### FIXED CODE ###

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


class UnionFind():
    def __init__(self, n):
        self.rank = [1 for _ in range(n)]
        self.parent = [i for i in range(n)]

    def union(self, i, j):
        i = self.root(i)
        j = self.root(j)
        if i == j:
            return
        if self.rank[i] < self.rank[j]:
            self.parent[i] = j
        else:
            if self.rank[i] == self.rank[j]:
                self.rank[j] += 1
            self.parent[j] = i

    def same(self, i, j):
        return self.root(i) == self.root(j)

    def root(self, i):
        if self.parent[i] != i:
            self.parent[i] = self.root(self.parent[i])
        return self.parent[i]


uf = UnionFind(N)

for _ in range(M):
    X, Y, _ = list(map(int, input().split()))
    uf.union(X-1, Y-1)

ans = 0

for i in range(N):
    if uf.parent[i] == i:
        ans += 1

print(ans)
a,b,c = map(int,input().split())
print("delicious" if b=c else "safe" if c-b-1<=a else "dangerous")

### FIXED CODE ###

a,b,c = map(int,input().split())
print("delicious" if b>=c else "safe" if c-b-1<a else "dangerous")
N,K = map(int,input().split())
tree_list = []
for i in range(N):
    tree_list.append(int(input()))
tree_list = sorted(tree_list)
ans = 10**9
for i in range(N-K+1):
    compare = tree_list[i+2]-tree_list[i]
    if ans > compare:
        ans = compare
    if ans == 0:
      break
print(ans)
    

### FIXED CODE ###

N,K = map(int,input().split())
tree_list = [int(input()) for _ in range(N)]
tree_list = sorted(tree_list)
ans = 10**9
for i in range(N-K+1):
    compare = tree_list[i+K-1]-tree_list[i]
    if ans > compare:
        ans = compare
print(ans)
import numpy as np

N=int(input())
Nstr=list(str(N))
sum=0
for i in np.arange(len(Nstr)):
    sum+=Nstr[i]
    
if (sum%9==0):
    print("Yes")
else:
    print("No")

### FIXED CODE ###

import numpy as np

N=int(input())
Nstr=list(str(N))
sum=0
for i in np.arange(len(Nstr)):
    sum+=int(Nstr[i])
    
if (sum%9==0):
    print("Yes")
else:
    print("No")
N = int(input())
list = map(int,input().split(" "))
cards = sorted(list,reverse=True)

if len(cards) % 2 == 0:
    alice = 0
    for i in range(int(N/2)):
        alice = alice + cards[2 * i]
        
    bob = 0
    for j in range(int(N/2)):
        bob = bob + cards[2 * j + 1]
    else:
        alice = 0
    for i in range(int(N/2) + 1):
        alice = alice + cards[2 * i]
        
    bob = 0
    for j in range(int(N/2)):
        bob = bob + cards[2 * j + 1]
    
print(alice - bob)

### FIXED CODE ###

N = int(input())
list = map(int,input().split(" "))
cards = sorted(list,reverse=True)

if len(cards) % 2 == 0:
    alice = 0
    for i in range(int(N/2)):
        alice = alice + cards[2 * i]
    bob = 0
    for j in range(int(N/2)):
        bob = bob + cards[2 * j + 1]
else:
    alice = 0
    for i in range(int(N/2) + 1):
        alice = alice + cards[2 * i]
    bob = 0
    for j in range(int(N/2)):
        bob = bob + cards[2 * j + 1]
        
print(alice - bob)
a, b, c = map(int, raw_input().split())
ans = a+b+c

print a+b+c

### FIXED CODE ###

# -*- coding: utf-8 -*-

#問題文
#すぬけ君は 1,2,3 の番号がついた 3 つのマスからなるマス目を持っています。 各マスには 0 か 1 が書かれており、マス i
# には si が書かれています。
#すぬけ君は 1 が書かれたマスにビー玉を置きます。 ビー玉が置かれるマスがいくつあるか求めてください。

#制約
#s1,s2,s3 は 1 あるいは 0

countup = 0
s = str(raw_input())
for count in s :
    if count == '1':
        countup += 1
    else:
        countup = countup

print countup
N=int(input())
A=list(map(int,input().split()))
from functools import reduce
from fractions import gcd
tmp=[]
for i in range(N):
    A.remove(i)
    tmp.append(reduce(gcd,A))
print(max(tmp))

### FIXED CODE ###

N=int(input())
A=list(map(int,input().split()))
from fractions import gcd
gcd_l=[0]
gcd_r=[0]
for i in range(N):
    gcd_l.append(gcd(gcd_l[i],A[i]))
    gcd_r.append(gcd(gcd_r[i],A[-(i+1)]))
gcd_r=gcd_r[::-1]
ans=[]
for i in range(N):
    ans.append(gcd(gcd_l[i],gcd_r[i+1]))
print(max(ans))
import sys
import numpy as np
from collections import deque
A, B = map(int, sys.stdin.readline().split())

a, b = deque([]), deque([])
for i in range(A, 0, -1):
    if A%i ==0:
        a.append(i)
    
for i in range(B, 0, -1):
    if B%i ==0:
        b.append(i)

a,b = set(a), set(b)
L = a&b
#print(L)
cnt =0
for l in L:
    tmp = 0
    for i in range(l-1, 1, -1):
        if l%i==0:
            tmp +=1
            break
    if tmp ==0:
        cnt+=1
print(cnt)

### FIXED CODE ###

import sys
import math

A, B = map(int, sys.stdin.readline().split())
C, D = max(A, B), min(A, B)

#ユーグリッド互除法
while True:
    amari = C%D
    C, D = D, amari
    if amari ==0:
        gcd = C
        break
#print(gcd)

#素因数分解
L = [1]
n = int(math.sqrt(gcd))
for i in range(2, n+1):
    while True:
        if gcd%i ==0:
            L.append(i)
            gcd = gcd//i
        else:
            break
if gcd>1:
    L.append(gcd)
L = set(L)
print(len(L))
#config:utf-8
x = input()

if int(x) < 100:
    print(0)
    return
if 5 * int(x[0:-2]) >= int(x[-2:]):
    print(1)
else:
    print(0)


### FIXED CODE ###

#config:utf-8
x = input()

if int(x) < 100:
    print(0)
elif 5 * int(x[0:-2]) >= int(x[-2:]):
    print(1)
else:
    print(0)
def Warshall_Floyd(d):
    #dist[i][j]:iからjへの最短距離
    for k in range(n):
        for i in range(n):
            for j in range(n):
                d[i][j] = min(d[i][j], d[i][k]+d[k][j])
    return d
############################
n, m, l = map(int, input().split())

f_inf = float('inf')
dist = [[f_inf for _ in range(n)] for _ in range(n)]
for i in range(m):
    dist[i][i] = 0

for _ in range(m):
    a, b, c = map(int, input().split())
    dist[a-1][b-1] = c
    dist[b-1][a-1] = c

Warshall_Floyd(dist)

dist2 = [[f_inf for _ in range(n)] for _ in range(n)]
for i in range(n):
    for j in range(n):
        if dist[i][j] <= l:
            dist2[i][j] = 1

Warshall_Floyd(dist2)

q = int(input())
for _ in range(q):
    s, t = map(int, input().split())
    ans = dist2[s-1][t-1]-1
    if dist2[s-1][t-1] == f_inf:
      ans = -1
    print(ans)

### FIXED CODE ###

import sys
input = sys.stdin.readline

def main():
    N, M, L = map(int, input().split())
    dist = [[float('inf')] * N for _ in range(N)]
    for _ in range(M):
        A, B, C = map(int, input().split())
        if C > L:
            continue
        A -= 1
        B -= 1
        dist[A][B] = C
        dist[B][A] = C

    for k in range(N):
        for i in range(N):
            for j in range(N):
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

    e = [[float('inf')] * N for _ in range(N)]
    for i in range(N):
        for j in range(N):
            if dist[i][j] <= L:
                e[i][j] = 1
    
    for k in range(N):
        for i in range(N):
            for j in range(N):
                e[i][j] = min(e[i][j], e[i][k] + e[k][j])


    Q = int(input())
    for _ in range(Q):
        s, t = map(int, input().split())
        s -= 1
        t -= 1
        if e[s][t] == float('inf'):
            print(-1)
            continue
        ans = e[s][t]
        print(ans-1)


if __name__ == "__main__":
    main()
s = int(input()).split()
print(s[0]*s[1],' ',s[0]*2+s[1]*2)

### FIXED CODE ###

s = input().split()
print(int(s[0])*int(s[1]),int(s[0])*2+int(s[1])*2)
n=int(input())
a=list(map(int,input().split()))
plus=[a[i] for i in range(n) if a[i]>=0]
l_plus=len(plus)
minus=[a[i] for i in range(n) if a[i]<0]
l_minus=len(minus)
x_cal=[]
y_cal=[]
if plus!=[] and minus!=[]:
  x_cal.append(minus[0])
  for j in range(1,l_plus-1):
    x_cal.append(x_cal[-1]-plus[j])
  for k in range(1,l_plus):
    y_cal.append(plus[k])
  y_last=x_cal[-1]-y_cal[-1]
  x_cal.append(plus[0])
  for ji in range(1,l_minus-1):
    x_cal.append(x_cal[-1]-minus[ji])
  for ki in range(1,l_minus):
    y_cal.append(minus[ki])
  y_cal.append(y_last)
  print(x_cal[-1]-y_cal[-1])
  for ii in range(n-1):
    print(x_cal[ii],y_cal[ii])
elif minus==[]:
  a.sort()
  print(sum(a)-2*a[0])
  x_cal.append(a[0])
  for ij in range(1,n-2):
    x_cal.append(x_cal[-1]-a[ij])
  for jj in range(0,n-2):
    y_cal.append(a[jj+1])
  y_cal.append(x_cal[-1]-y_cal[-1])
  x_cal.append(a[-1])
  for ii in range(n-1):
    print(x_cal[ii],y_cal[ii])
else:
  a.sort()
  print(a[-1]*2-sum(a))
  x_cal.append(a[-1])
  for ij in range(1,n-2):
    x_cal.append(x_cal[-1]-a[ij])
  for jk in range(0,n-2):
    y_cal.append(a[jk+1])
  x_cal.append(x_cal[-1]-y_cal[-1])
  y_cal.append(a[0])
  for ii in range(n-1):
    print(x_cal[ii],y_cal[ii])

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
plus=[a[i] for i in range(n) if a[i]>=0]
l_plus=len(plus)
minus=[a[i] for i in range(n) if a[i]<0]
l_minus=len(minus)
x_cal=[]
y_cal=[]
if n==2:
  a.sort()
  print(a[1]-a[0])
  print(a[0],a[1])
else:
  if plus!=[] and minus!=[]:
    if l_plus>1:
      x_cal.append(minus[0])
    for j in range(1,l_plus-1):
      x_cal.append(x_cal[-1]-plus[j])
    for k in range(1,l_plus):
      y_cal.append(plus[k])
    if l_plus>1:
      y_last=x_cal[-1]-y_cal[-1]
    else:
      y_last=minus[0]
    x_cal.append(plus[0])
    for j in range(1,l_minus):
      x_cal.append(x_cal[-1]-minus[j])
    for k in range(1,l_minus):
      y_cal.append(minus[k])
    y_cal.append(y_last)
    print(x_cal[-1]-y_cal[-1])
    for ii in range(n-1):
      print(x_cal[ii],y_cal[ii])
  elif minus==[]:
    a.sort()
    print(sum(a)-2*a[0])
    x_cal.append(a[0])
    for ij in range(1,n-2):
      x_cal.append(x_cal[-1]-a[ij])
    for jj in range(0,n-2):
      y_cal.append(a[jj+1])
    y_cal.append(x_cal[-1]-y_cal[-1])
    x_cal.append(a[-1])
    for ii in range(n-1):
      print(x_cal[ii],y_cal[ii])
  else:
    a.sort()
    print(a[-1]*2-sum(a))
    x_cal.append(a[-1])
    for ij in range(1,n-2):
      x_cal.append(x_cal[-1]-a[ij])
    for jj in range(0,n-2):
      y_cal.append(a[jj+1])
    x_cal.append(x_cal[-1]-y_cal[-1])
    y_cal.append(a[0])
    for ii in range(n-1):
      print(x_cal[ii],y_cal[ii])
n = int(input())
s = input()
print(s[:n/2]==s[n/2:] and n%2==0)


### FIXED CODE ###

n = int(input())
s = input()
if(s[:n//2]==s[n//2:] and n%2==0):
    print("Yes")
else:
    print("No")
input(a)
 
a + a * 2 + a * 3 = Z
	print("Z")

### FIXED CODE ###

a = int(input())
print(a + a**2 + a**3)
x = input()

if x == '7' or x == '5' or x == '3':
  print('YES'
else:
  print('NO')

### FIXED CODE ###

x = input()

if x == '7' or x == '5' or x == '3':
  print('YES')
else:
  print('NO')
FAST_IO = 1
if FAST_IO:
    import io, sys, atexit
    rr = iter(sys.stdin.read().splitlines()).next
    sys.stdout = _OUTPUT_BUFFER = io.BytesIO()

    @atexit.register
    def write():
        sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
else:
    rr = raw_input
rri = lambda: int(rr())
rrm = lambda: map(int, rr().split())
rrmm = lambda n: [rrm() for _ in xrange(n)]

n = rri()
arr = rrm()
ans = 0
for i in range(0, n,2):
    if arr[i]&1:
        ans+=1
print(ans)

### FIXED CODE ###

FAST_IO = 1
if FAST_IO:
    import io, sys, atexit
    rr = iter(sys.stdin.read().splitlines()).next
    sys.stdout = _OUTPUT_BUFFER = io.BytesIO()

    @atexit.register
    def write():
        sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
else:
    rr = raw_input
rri = lambda: int(rr())
rrm = lambda: map(int, rr().split())
rrmm = lambda n: [rrm() for _ in xrange(n)]

n = rri()
arr = rrm()
ans = 0
for i in range(0, n,2):
    if arr[i]&1:
        ans+=1
print(ans)
# -*- coding: utf-8 -*-
import sys,math
from functools import reduce
# ----------------------------------------------------------------
# Use Solve Function

def solve(lines):
    def dfs(res, flag, depth):
        if depth == N:
            return res
        if flag:
            return dfs(math.gcd(res, A[depth]), True, depth + 1)
        else:
            return max( dfs(res, True, depth + 1), dfs(math.gcd(res, A[depth]), False, depth + 1))

    N = int(lines.pop(0))
    A = list(map(int, lines.pop(0).split(' ')))
    print(dfs(0, False, 0) )
lines = [x.strip() for x in sys.stdin.readlines()]
solve(lines)

### FIXED CODE ###

# -*- coding: utf-8 -*-
import sys,fractions
from functools import reduce
# ----------------------------------------------------------------
# Use Solve Function

def solve(lines):
    N = int(lines.pop(0))
    A = list(map(int, lines.pop(0).split(' ')))

    _l = 0
    L = []
    for i in range(N-1):
        _l = fractions.gcd(_l, A[i])
        L.append(_l)
    L.insert(0,0)

    _r = 0
    R = []
    for i in range(N-1):
        _r = fractions.gcd(_r, A[N-i-1])
        R.append(_r)
    R.reverse()
    R.append(0)

    print(max([fractions.gcd(l,r) for l, r in zip(L,R)]))



lines = [x.strip() for x in sys.stdin.readlines()]

#
# solve !!
#
solve(lines)
def main():
    raw = []
    for i in range(4):
        raw.append(input())

    n = int(raw[0])
    a = raw[1]
    b = raw[2]
    c = raw[3]

    difference = [0] * n
    for i in range(n):
        n = {a[i], b[i], c[i]}
        difference[i] = len(n) - 1

    print(sum(difference))


if __name__ == "__main__":
    main()


### FIXED CODE ###

import sys


def main():
    raw = input().split(' ')
    n = int(raw[0])
    a = int(raw[1])
    b = int(raw[2])

    def get_max():
        return min(a, b)

    def get_min():
        return max(a + b - n, 0)

    print("{} {}".format(get_max(), get_min()))


if __name__ == "__main__":
    argv = sys.argv[1:]
    main()