Harryxun/stf_run huggingface dataset:
r,g,b=input().split()
sum=100*r+10*g+b
if sum%4==0:
  print("YES")
else:
  print("NO")

### FIXED CODE ###

i = list(map(int, input().split()))
s=i[1]*10+i[2]
if s%4==0:
  print("YES")
else :
  print("NO")
n = int(input())
List=list(map(int,input().split()))
result = 0


for i in 200:
	for j in range(n):
		if List[j]%2 != 0:
			break
		List[j] /= 2

	else:
		result += 1
		continue
	break
  
print(result)

### FIXED CODE ###

n = int(input())
List=list(map(int,input().split()))
result = 0


for i in range(200):
	for j in range(n):
		if List[j]%2 != 0:
			break
		List[j] /= 2

	else:
		result += 1
		continue
	break
  
print(result)
h,w=map(int,input().split())
L=[list(input()) for i in range(h)]
for i in range(h):
    for j in range(w):
        if L[i][j]=='#':
            if L[i][max(i-1,0)]!='#' and L[i][min(i+1,w-1)]!='#' and L[max(i-1,0)][j]!='#' and L[min(i+1,h-1)][i]!='#':
                print('No')
                exit()
print('Yes')

### FIXED CODE ###

h,w=map(int,input().split())
L=[list(input()) for i in range(h)]
for i in range(h):
    for j in range(w):
        if L[i][j]=='#':
            if L[i][max(j-1,0)]!='#' and L[i][min(j+1,w-1)]!='#' and L[max(i-1,0)][j]!='#' and L[min(i+1,h-1)][j]!='#':
                print('No')
                exit()
print('Yes')
# -*- coding: utf-8 -*-
# import functools

# @functools.lru_cache(maxsize=None)
# def paint(i, c):  # i = 0, 1, 2
#     cost = 0
#     for row in range(N):
#         for col in range(N):
#             if (row + col) % 3 == i:
#                 cost += D[G[row][col] - 1][c - 1]

#     return cost

# def cost(comb):
#     cost = 0
#     for i, c in enumerate(comb):
#         cost += paint(i, c)

#     return cost


def cost(comb):
    cost = 0
    for r in range(N):
        for c in range(N):
            if (r + c) % 3 == 0:
                cost += D[G[r][c] - 1][comb[0]]
            elif (r + c) % 3 == 1:
                cost += D[G[r][c] - 1][comb[1]]
            else:
                cost += D[G[r][c] - 1][comb[2]]


if __name__ == '__main__':
    from itertools import permutations
    N, C = map(int, input().split())
    D = [[int(_) for _ in input().split()] for i in range(C)]
    G = [[int(_) for _ in input().split()] for i in range(N)]
    combs = permutations(range(1, C + 1), 3)
    min_cost = min([cost(comb) for comb in combs])
    print(min_cost)


### FIXED CODE ###

# -*- coding: utf-8 -*-
N, C = map(int, input().split())

D = []
for c in range(C):
    D.append([int(d) for d in input().split()])

Gmod = [[0 for i in range(C)] for i in range(3)]
for n in range(N):
    for m, g in enumerate(input().split()):
        Gmod[(n + m) % 3][int(g) - 1] += 1

K = []
for c0 in range(C):
    d0 = sum([Gmod[0][c] * D[c][c0] for c in range(C)])
    for c1 in [i for i in range(C) if not i == c0]:
        d1 = sum([Gmod[1][c] * D[c][c1] for c in range(C)])
        for c2 in [i for i in range(C) if (not i == c0) and (not i == c1)]:
            d2 = sum([Gmod[2][c] * D[c][c2] for c in range(C)])
            K.append(d0 + d1 + d2)

print(min(K))
def main():
    input = sys.stdin.readline
    input = open("stdin.txt").readline
    try:
        N = int(input())
        A1 = list(map(int, input().split()))
        A2 = list(map(int, input().split()))
        
        if N == 1:
            print(A1[0] + A2[0])
            return
        dp = [[0]*2 for _ in range(N-1)]
        dp[0][0] = A1[0] + A1[1]
        dp[0][1] = A1[0] + A2[0]

        for i in range(1, N - 1):
            dp[i][0] = dp[i-1][0] + A1[i+1]
            dp[i][1] = max(dp[i-1][0], dp[i-1][1]) + A2[i]
        
        ans = max(dp[N-2][0], dp[N-2][1]) + A2[N-1]
        print(ans)
        
    finally:
        input = None

import sys; sys.setrecursionlimit(50000)
if __name__ == "__main__":
    main()


### FIXED CODE ###

def main():
    input = sys.stdin.readline
    try:
        N = int(input())
        A1 = list(map(int, input().split()))
        A2 = list(map(int, input().split()))
        
        if N == 1:
            print(A1[0] + A2[0])
            return
        dp = [[0]*2 for _ in range(N-1)]
        dp[0][0] = A1[0] + A1[1]
        dp[0][1] = A1[0] + A2[0]

        for i in range(1, N - 1):
            dp[i][0] = dp[i-1][0] + A1[i+1]
            dp[i][1] = max(dp[i-1][0], dp[i-1][1]) + A2[i]
        
        ans = max(dp[N-2][0], dp[N-2][1]) + A2[N-1]
        print(ans)
        
    finally:
        input = None

import sys; sys.setrecursionlimit(50000)
if __name__ == "__main__":
    main()
n=int(input())
if n%2==0:
  print(1/2)
else:
  print((n+1)/(2*a))
  

### FIXED CODE ###

N = int(input())



if N%2==0:
  print(0.5000000000)
else:
  print((N+1)/(2*N))
a,b,c,d=map(int,input().split())
o1='+'
o2='+'
o3='+'
for x in (a+b,a-b):
  for y in (c,-c):
    for z in (d,-d):
      if x+y+z==7:
        if x==a-b:
          o1='-'
        if y==-c:
          o2='-'
        if z==-d:
          o3='-'
print("{}{}{}{}{}{}{}=7".format(a,o1,b,o2,c,o3,d))


### FIXED CODE ###

line=str(input())
line=list(line)
line=list(map(int,line))
a=line[0]
b=line[1]
c=line[2]
d=line[3]
o1='+'
o2='+'
o3='+'
count=0
for x in (a+b,a-b):
  for y in (c,-c):
    for z in (d,-d):
      if x+y+z==7 and count==0:
        if x==a-b:
          o1='-'
        if y==-c:
          o2='-'
        if z==-d:
          o3='-'
        count+=1
print("{}{}{}{}{}{}{}=7".format(a,o1,b,o2,c,o3,d))
x,y,z=map(int,input().split())

n=0
while(1):
    if(n*y+(n+1)*z>x):
        break
    n+=1

return(n)

### FIXED CODE ###

x,y,z=map(int,input().split())

n=0
while(1):
    if(n*y+(n+1)*z>x):
        break
    n+=1

print(n-1)
a= int(input())
b= int(input())
c = a+b
d = a-b
e = a*b
print(max(c,d,e))

### FIXED CODE ###

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

c = a+b
d = a-b
e = a*b
print(max(c,d,e))
A,B =[int(x) for x in input().split()]

def bunkai(n):
    sosu= [1]
    tmp = n
    
    if tmp%2 == 0:
        while tmp%2==0:
            tmp //=2
        sosu.append(2)
    
    stop_flag = n//2

    for i in range(3,(n//2)+1,2):
        if tmp%i == 0:
            while tmp%i==0:
                tmp //=i
            sosu.append(i)
        if i > stop_flag:
            break
        else:
            stop_flag //=i 
            
    if tmp!=1:
        sosu.append(tmp)
                
    if sosu==[1]:
        sosu.append[n]
    
    return sosu

def check_sosu(n,x):
    ans=0
    tmp = n
    for i in x:
        if (tmp % i) == 0:
            ans+=1
    return ans

ans = check_sosu(B,bunkai(A))

print(ans)


### FIXED CODE ###


A,B =[int(x) for x in input().split()]

def bunkai(n):
    sosu= {1}
    tmp = n
    stop_flag = n
    
    if tmp%2 == 0:
        while tmp%2==0:
            tmp //=2
        sosu.add(2)
    
    for i in range(3,n+1,2):
        if tmp%i == 0:
            while tmp%i==0:
                tmp //=i
            sosu.add(i)
            stop_flag = tmp 
            
        if i > stop_flag:
            break
        else:
            stop_flag = int(n/i)+1
            
    if tmp!=1:
        sosu.add(tmp)
                
    if sosu==[1]:
        sosu.add(n)
    
    return sosu

def check_sosu(n,x):
    ans=0
    tmp = n
    for i in x:
        if (tmp % i) == 0:
            ans+=1
    return ans

ans = check_sosu(B,bunkai(A))

print(ans)
S,T = map(input().split())
U = T + S
print(U)

### FIXED CODE ###

S,T = input().split()
U = ""
U = U + T + S
print(U)
a,b = map(int,input().split())
if a % 2 = 0 or b%2=0:
    print("No")
else:
    print("Yes")

### FIXED CODE ###

a,b = map(int,input().split())
if a % 2 == 0 or b%2==0:
    print("No")
else:
    print("Yes")
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

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

res = [0]*(100001)
for i in a: res[i] += 1


def check(N,P):
    if N == 1:
        if P[1]==1: return True
        else: return False
    res = []
    for i in range(1,N):
        if i*i >= N: break
        if N%i == 0:
            res.append(i)
            res.append(N//i)
    if i*i == N: res.append(i)
    
    for i in res:
        if i!=N and P[i] >= 1: return False
        if i==N and P[i] >= 2: return False
    return True    

ans = 0
for N in a:
    if check(N,res): ans += 1

print(ans)



### FIXED CODE ###

# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline

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

d = {}
for i in a:
    if i in d: d[i] += 1
    else: d[i] = 1

M = 10**6+1
sieve = [0]*(M)
for k,v in d.items():
    for i in range(k,M,k):
        sieve[i] += v


ans = 0
for ai in a:
    if sieve[ai] == 1:
        ans += 1

print(ans)
a, b, c = map(int, input().split())
print((a * b / (a + b)))


### FIXED CODE ###

a, b = map(int, input().split())
print((a * b / (a + b)))
def solve():
  T = int(input())
  ans = [0]*T
  for t in range(T):
    N = int(input())
    left = []
    right = []
    for i in range(N):
      k,l,r = map(int, input().split())
      if k==N:
        ans[t] += l
      elif l>r:
        left.append([k,l-r])
        ans[t] += r
      elif l<r:
        right.append([k,r-l])
        ans[t] += l
      else:
        ans[t] += l
    left.sort(key = lambda x:(-x[0],-x[1]))
    right.sort(key = lambda x:(x[0],-x[1]))
    now = left[0][0]
    ans[t] += left[0][1]
    for i in range(1,len(left)):
      while left[i][0]>=now:
        left[i][0] -= 1
      ans[t] += left[i][1]
      now -= 1
      if now==0:
        break
    now = right[0][1]
    for i in range(1,len(left)):
      while right[i][0]<=now:
        right[i][0] -= 1
      ans[t] += right[i][1]
      now -= 1
      if now==0:
        break
  return ans
print(*solve(),sep='\n')

### FIXED CODE ###

from bisect import *
from collections import defaultdict
def solve():
  T = int(input())
  ans = [0]*T
  for t in range(T):
    N = int(input())
    left = defaultdict(lambda: [])
    right = defaultdict(lambda: [])
    for i in range(N):
      k,l,r = map(int, input().split())
      if k==N:
        ans[t] += l
      else:
        if l>r:
          insort_right(left[k],l-r)
        elif l<r:
          insort_right(right[k+1],r-l)
        ans[t] += min(l,r)
    lis = []
    for i in range(N,0,-1):
      for l in left[i]:
        insort_right(lis,l)
      if len(lis):
        ans[t] += lis.pop(-1)
    lis = []
    for i in range(2,N+1):
      for r in right[i]:
        insort_right(lis,r)
      if len(lis):
        ans[t] += lis.pop(-1)
  return ans
print(*solve(),sep='\n')
input1 = input().split()
N = input1[0]
Q = input1[1]
S = input()

flag = 0
count = 0
result = []

for q in range(int(Q)):
	
	input3 = input().split()
	
	l = int(input3[0])
	r = int(input3[1])+1
	
	for s in (range(l,r)):
		
		#print(s)
		if S[s-1] == 'A':
			flag += 1
			
		elif ((S[s-1] == 'C') and (flag == 1)):
			count += 1
			flag = 0
			
		else:
			flag = 0
			
	result.append(count)
	
	count = 0
	flag = 0
	
for i in result:
	print(i)

### FIXED CODE ###

input = input()

a = {'A':'T', 'T':'A','C':'G','G':'C'}

print(a[input])
s = input()
for color in s:


### FIXED CODE ###

n=input()
s = input()
r_cnt = 0
b_cnt = 0
for color in s:
  if color == 'R':
    r_cnt += 1
  else:
    b_cnt += 1
else:
  if r_cnt > b_cnt:
    print('Yes')
  else:
    print('No')
a, b = map(int, input())
if a % 2 == 1 and b % 2 == 1:
  print("Odd")
else:
  print("Even")

### FIXED CODE ###

a, b = map(int, input().split())
if a % 2 == 1 and b % 2 == 1:
  print("Odd")
else:
  print("Even")
def resolve():
    X = int(input())
    b = 0
    while b < 10**6:
        a = (X-(b**5))**(1/5)
        if a.is_integer():
            print(int(a), b)
            return
        b += 1
    raise Exception("NOT FOUND")


if '__main__' == __name__:
    resolve()


### FIXED CODE ###

def resolve():
    X = int(input())
    for a in range(-200, 201):
        for b in range(-200, 201):
            if a**5 - b**5 == X:
                print(a, b)
                return
    assert False


if '__main__' == __name__:
    resolve()
x,y = map(int,input().split())

hx = hex(x)
hy = hex(y)

if hx < hy:
  print("<")
elif hy > hx:
  print(">")
else:
  print("=")


### FIXED CODE ###

x,y = input().split()

if x < y:
  print("<")
elif x > y:
  print(">")
else:
  print("=")
import sys

lines = sys.stdin.readlines()

H, M = list(map(int, lines[0].split()))
AB = []

max_at = 0
min_mg = 999999
at_min_mg = 0
for i in range(M):
  t = tuple(map(int, lines[i+1].split()))
  AB.append(t)
  if t[0]>max_at:
    max_at = t[0]
  if t[1]>min_mg:
    min_mg = t[1]
    at_min_mg = t[0]

ABlen = len(AB)

DP = [0]
for i in range(1, at_min_mg+1):
  DP.append(min_mg)
  
for i in range(at_min_mg+1,H+max_at):
  mm = 999999
  for j in range(ABlen):
    if i-AB[j][0]<0:
      continue
    if mm > DP[i-AB[j][0]]+AB[j][1]:
      mm = DP[i-AB[j][0]]+AB[j][1]
  DP.append(mm)
print(min(DP[H:H+max_at-1]))

### FIXED CODE ###

import sys

lines = sys.stdin.readlines()

H, M = list(map(int, lines[0].split()))
AB = []

max_at = 0
min_mg = sys.maxsize
at_min_mg = 0
for i in range(M):
  t = tuple(map(int, lines[i+1].split()))
  AB.append(t)
  if t[0]>=max_at:
    max_at = t[0]
  if t[1]<=min_mg:
    min_mg = t[1]
    at_min_mg = t[0]

ABlen = len(AB)

DP = [0]
for i in range(1, at_min_mg+1):
  DP.append(min_mg)
  
for i in range(at_min_mg+1,H+max_at+1):
  mm = sys.maxsize
  for j in range(ABlen):
    if i-AB[j][0]<0:
      continue
    if mm > DP[i-AB[j][0]]+AB[j][1]:
      mm = DP[i-AB[j][0]]+AB[j][1]
  DP.append(mm)
print(min(DP[H:H+max_at]))
import numpy as np

tmp =list(map(int, input().split()))
num=list(map(int, input().split()))

a[a>int(tmp[0]//2)]=np.abs(a[a>int(tmp[0]//2)]-int(tmp[0]//2))

print(sum(a))

### FIXED CODE ###

import numpy as np
 
tmp =list(map(int, input().split()))
num=list(map(int, input().split()))

num.append(num[0]+tmp[0])

print(np.diff(num).sum()-np.diff(num).max())
k=int(input())
a,b=map(int,input().split())
for i in range(a,b):
    c=i
    if i%k==0:
        print("OK")
        break
if c%k!=0:
    print("NG")
if k==1:
    print("OK")

### FIXED CODE ###

k=int(input())
a,b=map(int,input().split())
for i in range(a,b+1):
    c=i
    if i%k==0:
        print("OK")
        break
if c%k!=0:
    print("NG")
import sys
sys.setrecursionlimit(20000)
def getMax(d,n,c):
    global bs
    if len(d[n])==0:
        bs=max(bs,c)

    for k in d[n]:
        getMax(d,k,c+1)

n,m=map(int,input().split())
d={}
for j in range(1,n+1):
    d[j]=[]
for i in range(m):
    a,b=map(int,input().split())
    d[a].append(b)
bs=-1
for i in range(1,n+1):
    c=0
    getMax(d,i,c)
print(bs)


### FIXED CODE ###

n=int(input())
h=list(map(int,input().split()))
dp=[0 for _ in range(n)]
dp[0]=0
dp[1]=abs(h[0]-h[1])
for i in range(2,n):
    x=dp[i-1]+abs(h[i-1]-h[i])
    x1 = dp[i - 2] + abs(h[i - 2] - h[i])
    dp[i]=min(x,x1)
print(dp[-1])
import sys
input = sys.stdin.readline

def main():
    N, M = map(int, input().split())
    V = [True] * N
    H = [int(v) for v in input().split()]
    AB = [[map(int, input().split())] for _ in range(M)]
    for ab in AB:
        a, b = ab
        a-=1
        b-=1
        # if V[a] or V[b]:
        if H[a] < H[b]:
            V[a] = False
        else:
            V[b] = False
    
    print(V.count(True))

if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys
input = sys.stdin.readline

def main():
    N, M = map(int, input().split())
    V = [True] * N
    H = [int(v) for v in input().split()]
    AB = [[int(v) - 1 for v in input().split()] for _ in range(M)]
    for a, b in AB:
        # if V[a] or V[b]:
        if H[a] <= H[b]:
            V[a] = False
        if H[a] >= H[b]:
            V[b] = False
    
    print(V.count(True))

if __name__ == '__main__':
    main()
import math
A,B= map(int, input().split())
def lcm(A,B):
    return (A*B)//math.gcd(A,B)
print(lcm(A,B))

### FIXED CODE ###

a,b = map(int, input().split())
 
 #最大公約数
def gcd(a,b):
    while b!=0:
        a,b=b,a%b
    return a
#print(gcd(a,b))

 #最小公倍数
def lcm(a,b):
    return a*b//gcd(a,b)
print(lcm(a,b))
import bisect, functools, sys
sys.setrecursionlimit(10**6)
N = int(input())
A = sorted(int(x) for x in input().split())
B = sorted(int(x) for x in input().split())
C = sorted(int(x) for x in input().split())

@functools.lru_cache(maxsize=None)
def a(n):
    return bisect.bisect_left(A, n)

b_cache = [0] * N
b_cached = [False] * N
def b_i(i):
    if i >= 1:
        if not b_cached[i - 1]: b_i(i - 1)
        t = b_cahce[i - 1] + a(B[i - 1])
        b_cache[i] = t
        b_cached[i] = True
        return t
    return 0

@functools.lru_cache(maxsize=None)
def b(n):
    return b_i(min(len(B), bisect.bisect_left(B, n)))

def c():
    return sum(b(x) for x in C)

print(c())

### FIXED CODE ###

import bisect, functools, sys
sys.setrecursionlimit(10**6)
N = int(input())
A = sorted(int(x) for x in input().split())
B = sorted(int(x) for x in input().split())
C = sorted(int(x) for x in input().split())

@functools.lru_cache(maxsize=None)
def a(n):
    return bisect.bisect_left(A, n)

b_cache = [0] * (N + 1)
b_cached = [False] * (N + 1)
def b_i(i):
    global b_cache, b_cached
    if i >= 1:
        if not b_cached[i - 1]: b_i(i - 1)
        t = b_cache[i - 1] + a(B[i - 1])
        b_cache[i] = t
        b_cached[i] = True
        return t
    return 0

@functools.lru_cache(maxsize=None)
def b(n):
    return b_i(min(N, bisect.bisect_left(B, n)))

def c():
    return sum(b(x) for x in C)

print(c())
n,m,k = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a_sum = [0]
b_sum = [0]
for i in range(n):
    a_sum.append(a[i]+a_sum[i])
    if a_sum[i]>1e+9:
        break
for i in range(m):
    b_sum.append(b[i]+b_sum[i])
    if b_sum[i]>1e+9:
        break
        
ans = 0
for i in range(len(b_sum)):
    if a_sum[i]>k:
        break
    time = k - a_sum[i]
    for j in range(len(b_sum)):
        if time<b_sum[j+1]:
            break
    if time>=b_sum[len(b_sum)]:
        j = len(b_sum)
    ans = max(ans,i+j)
    
print(ans)

### FIXED CODE ###

n,m,k = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
a_sum = [0]
b_sum = [0]
for i in range(n):
    a_sum.append(a[i]+a_sum[i])
    if a_sum[i]>k:
        break
for i in range(m):
    b_sum.append(b[i]+b_sum[i])
    if b_sum[i]>k:
        break
        
ans = 0
y = len(b_sum)-1
for i in range(len(a_sum)):
    if a_sum[i]>k:
        break
    time = k - a_sum[i]
    for j in range(y,-1,-1):
        if time>=b_sum[j]:
            y = j
            break
    if time>=b_sum[len(b_sum)-1]:
        j = len(b_sum)-1
    ans = max(ans,i+j)
    
print(ans)
N = int(input())
ans = "Four" if 'Y' in list(map(int, input().split())) else "Three"
print(ans)


### FIXED CODE ###

N = int(input())
ans = "Four" if 'Y' in list(input().split()) else "Three"
print(ans)
n,s=map(int,input().split())
dp=[[0]*(s+1) for _ in range(n)]
a=list(map(int,input().split()))
if s>=a[0]:dp[0][a[0]]=1
for i in range(1,n):
  if s>=a[0]:dp[i][a[i]]=i+1
  for j in range(s+1):
    dp[i][j]+=dp[i-1][j]
    if j-a[i]>=0:dp[i][j]+=dp[i-1][j-a[i]]
print(sum(dp[i][s]for i in range(n)))

### FIXED CODE ###

n,s=map(int,input().split())
a=list(map(int,input().split()))
dp=[0]*6007
ans=0
for i in range(n):
  for j in range(s,0,-1):dp[a[i]+j]+=dp[j]
  dp[a[i]]+=i+1
  ans+=dp[s]
print(ans%998244353)
import sys
import math

sys.setrecursionlimit(1000000)
input = lambda: sys.stdin.readline().rstrip()

N, M = map(int, input().split())
a = list(map(lambda x : int(x) // 2, input().split()))
lcm = 1
for i in a:
    lcm = lcm * i // math.gcd(lcm, i)
ok = True
for i in a:
    if lcm // i % 2 == 0:
        ok = False

if not ok:
    print(0)
else:
    print((M // lcm - 1) // 2 + 1)

### FIXED CODE ###

import sys
import math

def gcd(x, y):
    if x < y:
        return gcd(y, x)
    if y == 0:
        return x
    return gcd(y, x % y)

sys.setrecursionlimit(1000000)
input = lambda: sys.stdin.readline().rstrip()

N, M = map(int, input().split())
a = list(map(lambda x : int(x) // 2, input().split()))
lcm = 1
for i in a:
    lcm = lcm * i // gcd(lcm, i)
ok = True
for i in a:
    if lcm // i % 2 == 0:
        ok = False

if not ok:
    print(0)
else:
    print((M // lcm - 1) // 2 + 1)
from operator import mul
from functools import reduce
n = int(input())
a = list(map(int,input().split()))
M = 10**18
if 0 in a:
	print(0)
	break
else:
	ans = reduce(mul, a)
	if ans > M:
		print(-1)
		break
	else:
		print(ans)


### FIXED CODE ###

n = int(input())
s = sorted(map(int,input().split()))
M = 10 ** 18
ans = 1
for ss in s:
	ans *= ss
	if ans > M:
		ans = -1
		break
	elif ans == 0:
		break
print(ans)
from heapq import heappop, heappush
ab = lambda a,b:abs(a-b)
area = lambda a,b:ab(a[1],b[1])*ab(a[0],b[0])
dist = lambda a,b:(ab(a[1],b[1])**2+ab(a[0],b[0])**2)>>1

N, K = map(int, input().split())
A = []
graph = []
inf = float('INF')
mn_x, mn_y, mx_x, mx_y = inf, inf, 0, 0
for i in range(N):
    a,b = map(int, input().split())
    A.append([a,b])
    graph.append([inf for i in range(N)])
    mn_x, mn_y, mx_x, mx_y = min(mn_x, a), min(mn_y, b), max(mx_x, a), max(mx_y, b)

if N == 2:
    print(area(a,b))
    exit()
center = [(mx_x - mn_x) // 2, (mx_y - mn_y) // 2]
mn_dist = inf
for i in range(N):
    for j in range(N):
        if i == j:
            continue
        graph[i][j] = graph[j][i] = dist(A[i], A[j]) + dist(A[j], center)
        if mn_dist > graph[i][j]:
            mn_dist = graph[i][j]
            mn_dict = {i:1,j:1}
            mn_lst = [i,j]

x_lst = [A[mn_lst[0]][0], A[mn_lst[1]][0]]
y_lst = [A[mn_lst[0]][1], A[mn_lst[1]][1]]
cands = []
tmp = min([[graph[mn_lst[0]][i], i] for i in range(N) if i not in mn_dict])
heappush(cands, tmp)
tmp = min([[graph[mn_lst[1]][i], i] for i in range(N) if i not in mn_dict])
heappush(cands, tmp)
    
for i in range(K-2):
    _, idx = heappop(cands)
    mn_dict[idx] = 1
    mn_lst.append(idx)
    x_lst.append(A[idx][0])
    y_lst.append(A[idx][1])
    # print(idx, mn_lst, graph[3][3])
    tmp_lst = [[graph[idx][i], i] for i in range(N) if i not in mn_dict]
    if tmp_lst != []:
        tmp = min(tmp_lst)
        heappush(cands, tmp)

a = [min(x_lst), min(y_lst)]
b = [max(x_lst), max(y_lst)]
print(area(a,b))
# for i in range(N):
#     print(graph[i])
# print(a,b, cands)


### FIXED CODE ###

ab = lambda a,b:abs(a-b)
area = lambda a,b:ab(a[1],b[1])*ab(a[0],b[0])

N, K = map(int, input().split())
A = []
x_lst = []
y_lst = []
for i in range(N):
    a,b = map(int, input().split())
    A.append([a,b])
    x_lst.append(a)
    y_lst.append(b)

x_lst.sort()
y_lst.sort()
mn = float('INF')
for x in range(N-1):
    for x_ in range(x,N):
        for y in range(N-1):
            for y_ in range(y,N):
                cnt = 0
                for a,b in A:
                    if x_lst[x] <= a <= x_lst[x_] and y_lst[y] <= b <= y_lst[y_]:
                        cnt += 1
                if cnt >= K:
                    mn = min(mn, area([x_lst[x],y_lst[y]], [x_lst[x_], y_lst[y_]]))
print(mn)
W = map(int,input().split())
if sum(W[:2]) < sum(W[2:]):
  print("Right")
elif sum(W[:2]) > sum(W[2:]):
  print("Left")
else:
  print("Balanced")

### FIXED CODE ###

W = list(map(int,input().split()))
if sum(W[:2]) < sum(W[2:]):
  print("Right")
elif sum(W[:2]) > sum(W[2:]):
  print("Left")
else:
  print("Balanced")
W=int(raw_input())
H=int(raw_input())
x=int(raw_input())
y=int(raw_input())
r=int(raw_input())

if x <= W-r and x >= r and y <= H-r and y >= r:
    print "yes"
else:
  print "no"

### FIXED CODE ###

W,H,x,y,r= map(int, raw_input().split())
if r<=x and r<=y and x<=W-r and y<=H-r:
  print "Yes"
else : print "No"