Harryxun/stf_run huggingface dataset:
n,m=map(int,input().split())
inf=float("inf")
r=lambda n:range(n)

l=[[inf if i!=j else 0 for j in r(n)] for i in r(n)]
a,b,c=[None]*n,[None]*n,[None]*n

for i in r(m):
  a[i],b[i],c[i]=map(int,input().split())
  l[a[i]-1][b[i]-1]=c[i]
  l[b[i]-1][a[i]-1]=c[i]

for k in r(n):
  for i in r(n):
    for j in r(n):
      l[i][j]=min(l[i][j],l[i][k]+l[k][j])

ans=m
for i in r(m):
  f=False
  for j in r(n):
    if l[j][a[i]-1]+c[i]==l[j][b[i]-1]:
      f=True
  if f:ans-=1
print(ans)

### FIXED CODE ###

n,m=map(int,input().split())
inf=float("inf")

r=lambda n:range(n)
l=[[inf if i!=j else 0 for j in r(n)] for i in r(n)]
a,b,c=[None]*m,[None]*m,[None]*m

for i in r(m):
  a[i],b[i],c[i]=map(int,input().split())
  a[i]-=1
  b[i]-=1
  l[a[i]][b[i]]=c[i]
  l[b[i]][a[i]]=c[i]

for k in r(n):
  for i in r(n):
    for j in r(n):
      l[i][j]=min(l[i][j],l[i][k]+l[k][j])

ans=m
for i in r(m):
  f=False
  for j in r(n):
    if l[j][a[i]]+c[i]==l[j][b[i]]:
      f=True
  if f:ans-=1
print(ans)
import math
import time
import pprint
import sys
from queue import Queue
pp = pprint.PrettyPrinter(width = 30)
sys.setrecursionlimit(10**7)
INF = 10 ** 18
def MI(): return map(int, sys.stdin.readline().split())
def IS(): return input()
def bfs(start):
    q = Queue()
    for s in start:
        q.put(s)
    # かかる歩数
    require = [[0 for i in range(w)] for j in range(h)]
    # 訪れたかどうか
    check = [[0 for i in range(w)] for j in range(h)]
    x_diff = [-1, 0, 1, 0]
    y_diff = [0, 1, 0, -1]
    while q.qsize() != 0:
        tmp_x, tmp_y = q.get()
        for i in range(4):
            if ( 0 <= tmp_x + x_diff[i] <= w-1 
                    and 0 <= tmp_y + y_diff[i] <= h-1 
                    and check[tmp_x + x_diff[i]][tmp_y + y_diff[i]] == 0 
                    and a[tmp_x + x_diff[i]][tmp_y + y_diff[i]] != '#'):
                check[tmp_x + x_diff[i]][tmp_y + y_diff[i]] = 1 
                require[tmp_x + x_diff[i]][tmp_y + y_diff[i]] = require[tmp_x][tmp_y] + 1
                q.put([tmp_x + x_diff[i], tmp_y + y_diff[i]])
    return require


h, w = MI()
a = [IS() for _ in range(h)]
push = []
ans = [[INF for i in range(w)] for j in range(h)]
out = 0

for i in range(h):
    for j in range(w):
        if a[i][j] == '#':
            push.append([i,j])

ans = bfs(push)

for i in range(h):
    for j in range(w):
        out = max(out,ans[i][j])

print(out)


### FIXED CODE ###

import math
import time
import pprint
import sys
from collections import deque
pp = pprint.PrettyPrinter(width = 30)
sys.setrecursionlimit(10**7)
INF = 10 ** 18
def MI(): return map(int, sys.stdin.readline().split())
def IS(): return input()
def bfs(q):
    # かかる歩数
    require = [[0 for i in range(w)] for j in range(h)]
    # 訪れたかどうか
    check = [[0 for i in range(w)] for j in range(h)]
    x_diff = [-1, 0, 1, 0]
    y_diff = [0, 1, 0, -1]
    while len(q) != 0:
        tmp_y, tmp_x = q.popleft()
        # print(tmp_y, tmp_x)
        for i in range(4):
            next_y = tmp_y + y_diff[i]
            next_x = tmp_x + x_diff[i]
            if ( 0 <= next_x <= w-1 
                    and 0 <= next_y <= h-1 
                    and check[next_y][next_x] == 0 
                    and a[next_y][next_x] != '#'):
                check[next_y][next_x] = 1 
                require[next_y][next_x] = require[tmp_y][tmp_x] + 1
                q.append([next_y, next_x])
                # pp.pprint(check)
    return require


h, w = MI()
a = [IS() for _ in range(h)]
# start = time.time()
# h, w = 1000, 1000
# a = ['#.#.' * (w//4) for _ in range(h)]
out = 0
que = deque()

for i in range(h):
    for j in range(w):
        if a[i][j] == '#':
            que.append([i,j])
# print(que)

ans = bfs(que)

for i in range(h):
    for j in range(w):
        out = max(out,ans[i][j])

# print(time.time() - start)
print(out)
return r * r

### FIXED CODE ###

r = int(input())
print(r * r)
A, B, M = list(map(int,input().split()))
list_a = list(map(int,input().split()))
list_b = list(map(int,input().split()))
for i in range(M):
    x, y, c = list(map(int,input().split()))
buy = []
buy.append(min(list_a) + min(list_b))
buy.append(list_a[x] + list_b[y] - c)
answer = min(buy)
print(answer, buy)


### FIXED CODE ###

A, B, M = list(map(int,input().split()))
list_a = list(map(int,input().split()))
list_b = list(map(int,input().split()))
buy = []
buy.append(min(list_a) + min(list_b))
for i in range(M):
    x, y, c = list(map(int,input().split()))
    buy.append(list_a[x-1] + list_b[y-1] - c)
answer = min(buy)
print(answer)
import math
S = imput()
print(S * 2 * math.pi)

### FIXED CODE ###

S = int(input())
print(S*2*3.14)
def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return a // gcd(a, b) * b


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

lcm_ = 1
sum_A = 0
for i in range(N):
    lcm_ = lcm(lcm_, A[i])
    sum_A += 1 / A[i]

ans = lcm_ * sum_A % mod

print(int(ans % mod))

### FIXED CODE ###

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, a % b)

def lcm(a, b):
    return a // gcd(a, b) * b


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

lcm_ = 1
for i in range(N):
    lcm_ = lcm(lcm_, A[i])

ans = 0
for i in range(N):
    ans += lcm_ // A[i]

print(ans % mod)
q,h,s,d = map(int,input().split())
N = int(input())
one = min(q*4,h*2,s)
print(min(one*N,d*(N//2)+one*(n%2)))


### FIXED CODE ###

from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
#    d = m - k[i] - k[j]
#    if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#

import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7

def readInts():
  return list(map(int,input().split()))
def main():
    q,h,s,d = readInts()
    n = int(input())
    # 2A < B なら 0.25 のみ
    # 2A > B なら　0.5 のみ。
    # "入力は整数であるから、小数点を考える必要がない"
    # よって、0.25 -> 1, 0.5 -> 1 として、かつ1と比較する
    one = min(q*4, h*2, s)
    # そして、1gだけで行けるか、
    # 2gだけで買えるだけ買って、余った分を1gでやる
    print(min(one*n, d*(n//2) + one * (n%2)))#n//2 は 2g ずつなので、 n%2 は1gするか

if __name__ == '__main__':
  main()
import sys
# from collections import deque
# from collections import Counter
# from math import sqrt
# from math import log
# from math import ceil

# def gcd(a, b):
# 	if(a==0):
# 		return b 
# 	return gcd(b%a,a)

# def sieve(n): 
# 	prime=[True for i in range(n+1)]
# 	p=2
# 	while(p*p<=n): 
# 		if (prime[p]==True): 
# 			for i in range(p*p,n+1,p): 
# 				prime[i]=False
# 		p+=1
# 	prime[0]=False
# 	prime[1]=False
# 	s=set()
# 	for i in range(len(prime)):
# 		if(prime[i]):
# 		s.add(i)
# 	return s 

# alpha=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# mod=10**9+7

fast_reader=sys.stdin.readline
fast_writer=sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i)) for i in argv))
	fast_writer('\n')

def list_input():
	return list(map(int, input().split()))

def sep_input():
	return map(int, input().split())

#_______________________________________________________________________________________________________________________________________

x,n=sep_input()
l=list_input()
s=set(l)
i=0
while(True):
	if(x-i not in s):
		print(x-i)
		break
	elif(x+i not in s):
		print(x+i)
		break
	else:
		i+=1

### FIXED CODE ###

import sys
# from collections import deque
# from collections import Counter
# from math import sqrt
# from math import log
# from math import ceil

# def gcd(a, b):
# 	if(a==0):
# 		return b 
# 	return gcd(b%a,a)

# def sieve(n): 
# 	prime=[True for i in range(n+1)]
# 	p=2
# 	while(p*p<=n): 
# 		if (prime[p]==True): 
# 			for i in range(p*p,n+1,p): 
# 				prime[i]=False
# 		p+=1
# 	prime[0]=False
# 	prime[1]=False
# 	s=set()
# 	for i in range(len(prime)):
# 		if(prime[i]):
# 		s.add(i)
# 	return s 

# alpha=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# mod=10**9+7

fast_reader=sys.stdin.readline
fast_writer=sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i)) for i in argv))
	fast_writer('\n')

def list_input():
	return list(map(int, input().split()))

def sep_input():
	return map(int, input().split())

#_______________________________________________________________________________________________________________________________________

l=list_input()
print(15-sum(l))
l, m, n = map(int,input().split())
a = [[0 for i in range(m)]for j in range(l)]
b = [[0 for i in range(n)]for j in range(m)]
c = [[0 for i in range(n)]for j in range(l)]

for i in range(l):
 a[i] = list(map(int, input().split()))

for i in range(m):
 b[i] = list(map(int, input().split()))

for i in range(l):
 for j in range(n):
  for k in range(m):
   c[i][j] += a[i][m] * b[m][j]
 print(" ".join([str(x) for x in c[i]]))

### FIXED CODE ###

l, m, n = map(int,input().split())
a = [[0 for i in range(m)] for i in range(l)]
b = [[0 for i in range(n)] for i in range(m)]
c = [[0 for i in range(n)] for i in range(l)]

for i in range(l):
 a[i] = [int(x) for x in input().split()]

for i in range(m):
 b[i] = [int(x) for x in input().split()]

for i in range(l):
 for j in range(n):
  for k in range(m):
   c[i][j] += (a[i][k] * b[k][j])
 print(" ".join([str(x) for x in c[i]]))
def odd(a):
    return a/2

def even(b):
    return 3*b+1

num = int(input())
box = [num]
cnt = 0
answer = 0
while(True):
    if(num%2 == 0):
        num = odd(num)
    else:
        num = even(num)
    box.append(num)
    for i in range(len(box)-1):
        if(box[i] == num):
            answer = i
    if(answer != 0):
        print(str(i+2))
        break

### FIXED CODE ###

x = input()
box= x.split(" ")

add = int(box[0]) * int(box[1])/ 2
print(int(add))
S=input()
for i in range(len(S)):
    S[i]='×'
print(S)

### FIXED CODE ###

S=input()
a=[]
for i in range(len(S)):
    a.append('x')
print(''.join(a))
import sys
d0=[0]*1024
d1=[[0 for i in range(286)]for j in range(1024)]
B=[1,2,4,8,16,32,64,128,256,512]

def init():
  global d
  for i in range(1024):
    binary=format(i,'b')
    n0=binary.count('1')
    d0[i]=n0
    if n0==1:
      d1[i][B.index(i)]=1
    else:
      for j in range(len(binary)):
        dp=n0*j
        if binary[-j-1]=='1':
          i2=i-B[j]
          for k in range(286-dp):
            d1[i][k+dp]+=d1[i2][k]
  return
  
def f0070(n,s):
  x=sum([d1[i][s] for i in range(1024) if d0[i]==n])
  return x

init()
for a in sys.stdin:
  n,s=map(int,a.split())
  print f0070(n,s)

### FIXED CODE ###

import sys
K=1024
N=331
R=range(K)
B=[1,2,4,8,16,32,64,128,256,512]
C=[0]*K
D=[[0 for i in range(N)]for j in R]

for i in R:
  s=format(i,'b')
  n=s.count('1')
  C[i]=n
  if n==1:D[i][B.index(i)]=1
  else:
    for j in range(len(s)):
      if s[-j-1]=='1':
        dp=n*j
        i2=i-B[j]
        for k in range(N-dp):
          D[i][k+dp]+=D[i2][k]
   
for a in sys.stdin:
  n,s=map(int,a.split())
  x=0
  if s<N:x=sum([D[i][s] for i in R if C[i]==n])
  print x
#!/usr/bin/env python

ALPHA = sorted([a for a in "zyxwvutsrqponmlkjihgfedcba"])


def main():
    S = input()

    if 'zyxwvutsrqponmlkjihgfedcba' == S:
        return -1

    S = [s for s in S]
    ans = []
    for s in S:
        if s in ALPHA:
            ALPHA.remove(s)
            ans.append(s)
        else:
            ans.append(ALPHA.pop(0))
            break
    else:
        ans.append(ALPHA.pop(0))

    print("".join(ans))


if __name__ == '__main__':
    main()

### FIXED CODE ###

#!/usr/bin/env python
import itertools

ALPHA = sorted([s for s in 'zyxwvutsrqponmlkjihgfedcba'])


def main():
    S = input().strip()

    if 'zyxwvutsrqponmlkjihgfedcba' == S:
        return '-1'

    if len(set(ALPHA) - set([s for s in S])) != 0:
        return S + sorted(set(ALPHA) - set([s for s in S]))[0]

    for i in range(len(S) - 1, 0, -1):
        if S[i - 1] > S[i]:
            pass
        else:
            break

    for a in sorted(set(ALPHA) - set(S[:i])):
        if a > S[i - 1]:
            return S[:i - 1] + a


if __name__ == '__main__':
    ans = main()
    print(ans)
a = int(input())
b = int(input())

print((a - 1) * (b - 1))

### FIXED CODE ###

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

print((a - 1) * (b - 1))
#!/usr/bin/env python3

#import
#import math
#import numpy as np
#= int(input())
S = input()
K = int(input())
ls = len(S)
t1 = []

t = 1
for i in range(1, ls):
    if S[i - 1] == S[i]:
        t += 1
    else:
        if t > 1:
            t1.append(t)
        t = 1

if t > 1:
    t1.append(t)

ans = 0
for t in t1:
    ans += t // 2

if len(t1) == 1:
    if t1[0] == ls:
        print(ls * K // 2)

else:
    if S[0] != S[-1]:
        print(ans * K)
    
    else:
        ta = t1[0]
        tb = t1[-1]
        print(ans * K - (ta // 2 + tb // 2 - (ta + tb) // 2) * (K - 1))






### FIXED CODE ###

#!/usr/bin/env python3

#import
#import math
#import numpy as np
#= int(input())
S = input()
K = int(input())
ls = len(S)
t1 = []

t = 1
for i in range(1, ls):
    if S[i - 1] == S[i]:
        t += 1
    else:
        if t > 1:
            t1.append(t)
        t = 1

if t > 1 or t == ls:
    t1.append(t)

ans = 0
for t in t1:
    ans += t // 2

if len(t1) == 1:
    if t1[0] == ls:
        print(ls * K // 2)

else:
    if S[0] != S[-1]:
        print(ans * K)
    
    else:
        ta = t1[0]
        tb = t1[-1]
        print(ans * K - (ta // 2 + tb // 2 - (ta + tb) // 2) * (K - 1))
def solve2():
    N = int(raw_input())
    xy = [None] * N
    for i in range(N):
        xi, yi = [int(_) for _ in raw_input().split()]
        xy[i] = (xi, yi)
    xy.sort()
    dist = []
    for i in range(N):
        for j in range(i+1, N):
            p = xy[j][0] - xy[i][0]
            q = xy[j][1] - xy[i][1]
            dist.append((p,q))
    dist.sort()
    max_cnt = 0
    cnt = 1
    save = dist[0]
    for i in range(1, len(dist)):
        if dist[i] == save:
            cnt += 1
        else:
            max_cnt = max(cnt, max_cnt)
            cnt = 1
            save = dist[i]
    max_cnt = max(cnt, max_cnt)
    print N - max_cnt

if __name__ == '__main__':
    solve2()


### FIXED CODE ###


def solve2():
    N = int(raw_input())
    xy = [None] * N
    for i in range(N):
        xi, yi = [int(_) for _ in raw_input().split()]
        xy[i] = (xi, yi)
    if N == 1:
        print N
        return
    xy.sort()
    dist = []
    for i in range(N):
        for j in range(i+1, N):
            p = xy[j][0] - xy[i][0]
            q = xy[j][1] - xy[i][1]
            dist.append((p,q))
    dist.sort()
    max_cnt = 0
    cnt = 1
    save = dist[0]
    for i in range(1, len(dist)):
        if dist[i] == save:
            cnt += 1
        else:
            max_cnt = max(cnt, max_cnt)
            cnt = 1
            save = dist[i]
    max_cnt = max(cnt, max_cnt)
    print N - max_cnt

if __name__ == '__main__':
    solve2()
a = (list(map(int, input().split())))

if n==2:
    print(max(a))
    exit()
'''
L = [gcd(a[0], a[1])]
R = [gcd(a[n-2], a[n-1])]
'''
L = [0 for i in range(n+1)]
R = [0 for i in range(n+1)]
for i in range(1,n+1):
    L[i] = gcd(L[i-1], a[i-1])

for i in range(n)[::-1]:
    R[i] = gcd(R[i+1], a[i])

m = []

for i in range(n):
    m.append(gcd(L[i], R[i+1]))

print(max(m))


### FIXED CODE ###

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

def gcd(a,b):
    if b==0:return a
    return gcd(b,a%b)


n = int(input())

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

if n==2:
    print(max(a))
    exit()
'''
L = [gcd(a[0], a[1])]
R = [gcd(a[n-2], a[n-1])]
'''
L = [0 for i in range(n+1)]
R = [0 for i in range(n+1)]
for i in range(1,n+1):
    L[i] = gcd(L[i-1], a[i-1])

for i in range(n)[::-1]:
    R[i] = gcd(R[i+1], a[i])

m = [0 for i in range(n)]

for i in range(n):
    m[i] = gcd(L[i], R[i+1])

print(max(m))
N=int(input())
S=list(map(int,input().split()))
memo=[]
for i in range(min(S),max(S)):
    summ = 0
    for j in range(0,N):#実際にsumを求める
        summ+=(i-S[j])**2
    memo.append(summ)

print(min(memo))

### FIXED CODE ###

N=int(input())
S=list(map(int,input().split()))
memo=[]
for i in range(min(S)-100,max(S)+100):
    summ = 0
    for j in range(0,N):#実際にsumを求める
        summ+=(i-S[j])**2
    memo.append(summ)

print(min(memo))
import math

def main():
  R = input()
  if 1 <= R <= 100:
    answer = R * 2 / math.pi
  else:
    main()
  print(answer)
  
if __name__ == '__main__':
  main()

### FIXED CODE ###

import math

def main():
  R = input()
  answer = float(R) * 2 * math.pi  
  print(answer)
  
if __name__ == '__main__':
  main()
N = int(input())
S = []
for i in range(N):
    S.append(input())

S = sorted(S)
_list = []
ans = list(S.pop(1))
# print(S)
for e in range(len(S)):
    buff = ans.copy()
    buff2 = []
    for n in range(len(S[e])):

        # print(e, n, S[e])
        for a in range(len(buff)):
            if S[e][n] == buff[a]:
                buff2.append(buff[a])
                buff[a] = '00000000'

    # print(buff2)
    ans = buff2.copy()


ans = sorted(ans)
ans = ''.join(ans)

print(ans)

### FIXED CODE ###

N = int(input())
S = []
for i in range(N):
    S.append(input())

alfa = [chr(i) for i in range(97,97+26)]
counter = [1000000 for i in range(26)]

for s in S:
    for i in range(26):
        counter[i] = min(s.count(alfa[i]), counter[i])

ans = ''
for i in range(26):
    for j in range(counter[i]):
        ans += alfa[i]

print(ans)
import math
float R
R=float(input())
print(2*R*math.pi)

### FIXED CODE ###

import math
R=float(input())
print(2*R*math.pi)
import sys
import collections
stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

N,K,Q=nm()
Al=[0]*N
for i in range(Q):
    Al[i]=ni()



for i in range(N):
    #print(Al.count(i+1))
    print('No' if (K-Q+Al.count(i+1)<1) else 'Yes')

### FIXED CODE ###

import sys
stdin = sys.stdin

ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

S=list(ns())
S_o=''.join(S[0::2])
S_e=''.join(S[1::2])
print('Yes' if ((not ('L' in S_o)) and (not ('R' in S_e))) else 'No')
n, m = map(int, input().split())
a = sorted(list(map(int, input().split())))
bc = [list(map(int, input().split())) for i in range(m)]
sort_bc = sorted(bc, key = lambda x:x[1], reverse = True)
k = 0
for i in sort_bc:
    for j in range(i[0]):
        if k <= n:
            if i[1] > a[k]:
                a[k] = i[1]
                k += 1
        else:
            break
print(sum(a))

### FIXED CODE ###

n, m = map(int, input().split())
a = sorted(list(map(int, input().split())))
bc = [list(map(int, input().split())) for i in range(m)]
sort_bc = sorted(bc, key = lambda x:x[1], reverse = True)
cnt_a = 0
cnt_m = 0
for i in sort_bc:
    if cnt_a <= n - 1:
        for j in range(i[0]):
            if cnt_a <= n - 1:
                if i[1] > a[cnt_a]:
                    a[cnt_a] = i[1]
                    cnt_a += 1
                else:
                    break
    else:
        break
print(sum(a))
n=int(input())
print(1000*(n/500)+((n%500))

### FIXED CODE ###

n=int(input())
print(1000*(n//500)+5*((n%500)//5))
input(a)
if(a%2==1)
 i=(a+1)/2
 j=(a-1)/2
else 
 i=a/2
 j=a/2
print(i+j)

### FIXED CODE ###

a=int(input())
if a%2==0:
  ans=int((a/2)**2)
else:
  ans=int(((a-1)/2)*((a+1)/2))
print(ans)
a  = ''.join(list(map(input().split())))

print('YES' if int(a)%4==0 else 'NO')

### FIXED CODE ###

a  = ''.join(list(input().split()))

print('YES' if (int(a))%4==0 else 'NO')
N,X=map(int,input().split())
L=list(map(int,input().split()))
total=0
count=0
i=0
while total<=X:
    if i<=len(L):
        total+=L[i]
        i+=1
        count+=1
    else:
        break
print(count)

### FIXED CODE ###

N,X=map(int,input().split())
L=list(map(int,input().split()))
total=0
count=1
for i in range(N):
    total+=L[i]
    if total<=X:
        count+=1
print(count)
N = int(input())
yes = True
for _ in range(N):
  t, x, y = map(int, input().split())
  margin = t - (x + y)
  if not(margin >= 0 and margin % 2 == 0):
    yes = False
if yes:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

a, b = map(int, input().split())
if a % 2 == 0 or b % 2 == 0:
  print("Even")
else:
  print("Odd")
H,W=map(int,input().split())
S = [ input() for _ in range(H) ]
for h in range(H):
  L = ''
  for w in range(W):
    if S[h][w] == '#':
      L += '#'
    else:
      x = 0
      for dh in [ -1, 0, 1]:
        for dw in [-1, 0, 1]:
          if 0 <= h + dh < H and 0 <= w + dw < W and S[h+dh][w+dw] == '#':
            x += 1
      L += str(x)
  print(l)


### FIXED CODE ###

H,W=map(int,input().split())
S = [ input() for _ in range(H) ]
for h in range(H):
  L = ''
  for w in range(W):
    if S[h][w] == '#':
      L += '#'
    else:
      x = 0
      for dh in [ -1, 0, 1]:
        for dw in [-1, 0, 1]:
          if 0 <= h + dh < H and 0 <= w + dw < W and S[h+dh][w+dw] == '#':
            x += 1
      L += str(x)
  print(L)
n = int(input())

if n == 1:
  print('Hello World')
else if n == 2:
  a = int(input())
  b = int(input())
  print(a+b)

### FIXED CODE ###

n = int(input())

if n == 1:
  print('Hello World')
  exit()
elif n == 2:
  a = int(input())
  b = int(input())
  print(a+b)
import math

a, b, c = map(int, input().split())
res = False
n = abs(b * c // (b - a))
for i in range(n -1, n + 1 + 1):
    if a * i % b == c:
        res = True

print("YES" if res == True else "NO")

### FIXED CODE ###

a, b, c = map(int, input().split())
res = False
for i in range(a, a * b + 1, a):
    if i % b == c:
        res = True

print("YES" if res == True else "NO")
n = int(input())
lis = list(map(int, input().split()))
dp = {}
def TD(i):
    if i == n - 1:
        return 0

    if i in dp:
        return dp[i]
    mi = float('inf')
    for j in range(1, 3):
        if i + j < n:
            mi = min(mi, abs(lis[i] - lis[i+j])+TD(i+j))
    dp[i] = mi
    return mi
print(TD(0))   

### FIXED CODE ###

from types import GeneratorType
def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc
n = int(input())
lis = list(map(int, input().split()))
dp = {}
@bootstrap
def TD(i):
    if i == n - 1:
        yield 0

    if i in dp:
        yield dp[i]
    mi = float('inf')
    for j in range(1, 3):
        if i + j < n:
            tmp = yield TD(i+j)
            mi = min(mi, abs(lis[i] - lis[i+j])+ tmp)
    dp[i] = mi
    yield mi
print(TD(0))
from math import factorial

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

for i in range(1, K+1):
    ans = factorial(N - K + 1) * factorial(K - 1) / factorial(N - K + 1 - i) / factorial(i) / factorial(K - i) / factorial(i - 1) % mod
    print(int(ans))


### FIXED CODE ###

from operator import mul
from functools import reduce

MOD = 10 ** 9 + 7

def cmb(n, r):
    if n < r:
        return 0
    r = min(n - r, r)
    if r == 0:
        return 1
    numer = reduce(mul, range(n, n - r, -1))
    denom = reduce(mul, range(1, r + 1))
    return numer // denom % MOD
N, K = map(int, input().split())

for i in range(1, K + 1):
    print(cmb(K - 1, i - 1) * cmb(N - K + 1, i) % MOD)
n,m=map(int,input())
print((100*n+1800*m)*2**m)

### FIXED CODE ###

n,m=map(int,input().split())
print((100*n+1800*m)*2**m)