Harryxun/stf_run huggingface dataset:
L, R = map(int, input().split())

if R - L >= 2018:
      mod = 0
else:
    tempL = L%2019
    tempR = R%2019
    if tempR - tempL < R-L-1:
        temp = tempL
        tempL = 0
        X = range(tempL,temp)
        Y = range(tempR,2018)
        Z = extend(X,Y+1)
    else:
        Z = range(tempL,tempR+1)

ans = 2019
for i in range(len(Z)):
    for j in range(i+1, len(Z)):
        if (Z[i]*Z[j])%2019 < ans:
            ans = (Z[i]*Z[j])%2019
print(ans)


### FIXED CODE ###

L, R = map(int, input().split())

if R - L >= 2018:
      ans = 0
else:
    tempL = L%2019
    tempR = R%2019
    if tempR - tempL < R-L-1:
        temp = tempL
        tempL = 0
        X = list(range(tempL,temp))
        Y = list(range(tempR,2018+1))
        Z = X + Y
    else:
        Z = list(range(tempL,tempR+1))

    ans = 2019
    for i in range(len(Z)):
        for j in range(i+1, len(Z)):
            if (Z[i]*Z[j])%2019 < ans:
                ans = (Z[i]*Z[j])%2019
print(ans)
from math import gcd
def lcm(x, y):
    return (x * y) // gcd(x, y)

d = [int(i) for i in input().split()]

print(lcm(d[0],d[1]))


### FIXED CODE ###

from fractions import gcd
def lcm(x, y):
    return (x * y) // gcd(x, y)
 
d = [int(i) for i in input().split()]
 
print(lcm(d[0],d[1]))
n = int(input())
dp = [0] * (2**n)
s = []
for _ in range(n):
    s.append(int(input()))
for i in range(n):
    k = 2 ** i
    for j in range(k):
        dp[k+j] = dp[j] + s[i]
dp = [i if (i%10 != 0) else 0 for i in dp]
print(max(dp))

### FIXED CODE ###

n = int(input())
s = []
for _ in range(n):
    s.append(int(input()))
sum_s = sum(s)
if sum_s % 10 != 0:
    ans = sum_s
else:
    s_10 = [i for i in s if (i%10 != 0)]
    s_10.sort()
    if len(s_10) > 0:
        ans = sum_s - s_10[0]
    else:
        ans = 0
print(ans)
def possible(b):
    print('POSSIBLE' if b else 'IMPOSSIIBLE')

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

if k in A:
    possible(True)
    exit()

if n == 1:
    possible(False)
    exit()

A.sort()
D = [A[i + 1] - A[i] for i in range(n - 1)]
from fractions import *
g = D[0]
for d in D:
    g = gcd(g, d)

print('POSSIBLE' if k % g == 0 and k <= A[-1] else 'IMPOSSIBLE')


### FIXED CODE ###

def possible(b):
    print('POSSIBLE' if b else 'IMPOSSIBLE')
    exit()

n, k = map(int, input().split())
A = list(set(map(int, input().split())))
n = len(A)

if k in A:
    possible(True)

if k > max(A):
    possible(False)

if n == 1:
    possible(False)

A.sort()
D = [A[i + 1] - A[i] for i in range(n - 1)]
from fractions import *
g = D[0]
for d in D:
    g = gcd(g, d)

possible(k % g == 0)
S = input()
l = len(S)
dp = [[0]*2 for _ in range(l+1)]
for i in range(l):
  dp[i+1][0]=min(dp[i][1]+10-int(S[i]),dp[i][0]+int(S[i]))
  dp[i+1][1]=min(dp[i][1]+10-int(S[i])-1,dp[i][0]+int(S[i])+1)
print(min(dp[-1][0]+1,dp[-1][1])

### FIXED CODE ###

S = input()[::-1]
l = len(S)
dp = [[0]*2 for _ in range(l+1)]
for i in range(l):
  dp[i+1][0]=min(dp[i][0]+int(S[i]),dp[i][1]+int(S[i])+1)
  if i!=0:
    dp[i+1][1]=min(dp[i][0]+10-int(S[i]),dp[i][1]+10-(int(S[i])+1))
  else:
    dp[i+1][1]=dp[i][0]+10-int(S[i])
print(min(dp[-1][0],dp[-1][1]+1))
n = int(input())
l = list(map(int, input().split()))
def memo(n) :
    me = [-1]*(n+1)
    global l
    def f(n) :
        if n == 0 :
            return 0
        elif n == 1 :
            return abs(l[0] - l[1])
        else :
            if me[n] != -1 :
                return me[n]
            else :
                me[n] = min([f(n - 2) + abs(l[n - 2] - l[n]),f(n - 1) + abs(l[n - 1] - l[n])])
                return me[n]
    return f(n)
print(memo(n - 1))


### FIXED CODE ###

n = int(input())
l = list(map(int, input().split()))
def memo(n) :
    me = [0]*(n)
    global l
    me[0] = 0
    me[1] = abs(l[0] - l[1])
    def f(n) :
        for i in range(2, n) :
            me[i] = min([me[i - 2] + abs(l[i - 2] - l[i]),me[i - 1] + abs(l[i - 1] - l[i])])
        return me[n-1]
    return f(n)
print(memo(n))
n,m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]

c = [0,1]
ans = 0
for l,j,k in itertools.product(c,repeat=3):
    ans = max(ans,sum(sorted([a[i][0]*(-1)**l+a[i][1]*(-1)**j+a[i][2]*(-1)**k for i in range(n)])[n-m:]))

print(ans)

### FIXED CODE ###

import itertools
n,m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]

c = [0,1]
ans = 0
for l,j,k in itertools.product(c,repeat=3):
    ans = max(ans,sum(sorted([a[i][0]*(-1)**l+a[i][1]*(-1)**j+a[i][2]*(-1)**k for i in range(n)])[n-m:]))

print(ans)
n = int(input())
P =[]
s = 0
x,y = 
for _ in range(n):P.append([int(i) for i in input().split()])
P.append(P[0])
for j in range(n):s += P[j][0]*P[j+1][1] - P[j][1]*P[j+1][0]
print(s*0.5)

### FIXED CODE ###

x=range(int(input())-1,-1,-1)
P=[]
for _ in x:P+=[[int(i) for i in input().split()]]
P+=[P[0]]
for j in x:_+=P[j+1][1]*P[j][0]-P[j][1]*P[j+1][0]
print(_*0.5)
N = int(input())
T = int(input())
A = int(input())
H = list(map(int, input().split()))

ans_l = []

for i in range(N):
    mater = H[i]
    Temp = (T - (mater*0.006))
    ans = abs(A - Temp)
    ans_l.append(ans)
 
ans_mini = min(ans_l)

ans_posi =[]

for h in range(N):
    if ans_l[h] == ans_mini:
        ans2 = h+1
        ans_posi.append(ans2)


for j in ans_posi:
    print(j,end="")

### FIXED CODE ###

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


ans_l = []

for i in range(N):
    mater = H[i]
    Temp = (T - (mater*0.006))
    ans = abs(A - Temp)
    ans_l.append(ans)


ans_mini = min(ans_l)

ans_posi =[]

for h in range(N):
    if ans_l[h] == ans_mini:
        ans2 = h+1
        ans_posi.append(ans2)


for j in ans_posi:
    print(j,end="")
# -*- coding: utf-8 -*-


class FactMod():
    '''
    modの値が素数の時のfactと組み合わせを求める
    フェルマーの小定理を用いているため、modが素数以外の時は使えない
    '''

    def __init__(self, n, mod):
        '''
        コンストラクタ
        f:nまでの i!の値を　配列に入れる
        inv: (i!)^-1　の値を配列に入れる
        '''
        self.mod = mod
        self.f = [1]*(n+1)
        for i in range(1, n+1):
            self.f[i] = self.f[i-1]*i % mod

        self.inv = [pow(self.f[-1], mod-2, mod)]
        for i in range(1, n+1)[::-1]:
            self.inv.append(self.inv[-1]*i % mod)
        self.inv.reverse()

    def fact(self, n):
        '''
        n!の値を返す
        '''
        return self.f[n]

    def comb(self, n, r):
        '''
        nCrの値を返す
        '''
        ret = self.f[n] * self.inv[n-r]*self.inv[r]
        ret %= self.mod
        return ret

    def perm(self, n, r):
        """
        nPrの値を返す
        """
        ret = self.f[n] * self.inv[n-r]
        ret %= self.mod
        return ret


N, A, B = map(int, input().split())
MOD = 10**9+7
F = FactMod(N+1, MOD)

print((pow(N, 2, MOD)-1 - F.comb(N, A) - F.comb(N, B)+MOD) % MOD)


### FIXED CODE ###

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


def comb(N, A):
    x = 1
    for i in range(A):
        x *= N
        N -= 1
        x %= MOD
    y = 1
    for i in range(A):
        y *= A
        A -= 1
        y %= MOD
    return x*pow(y, MOD-2, MOD) % MOD


N, A, B = map(int, input().split())
MOD = 10**9+7
print((pow(2, N, MOD)-1-comb(N, A)-comb(N, B)+MOD) % MOD)
n = int(input())
sl = []
for _ in range(n):
    sl.append(input())
rl=[[0 for _ in range(26)] for _ in range(n)]
for i in range(n):
    for c in sl[i]:
        a=ord(c)-ord('a')
        rl[i][a]+=1
rslt=0
for i in range(n-1):
    for j in range(i+1,n):
        if rl[i] == rl[j]: rslt+=1
print(rslt)


### FIXED CODE ###

import heapq

N,M = map(int, input().split())
jobs = [[] for _ in range(M)]
for _ in range(N):
    a,b = map(int, input().split())
    if a <= M: jobs[a-1].append(b)
h=[]
rsl=0
for i in range(M):
    for j in jobs[i]:
        heapq.heappush(h, -j)
    if len(h) > 0:
        rsl += -heapq.heappop(h)
print(rsl)
x,y,a,b,c = map(int,input().split())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))

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

ppick = p[-x:]
qpick = q[-y:]

pi = 0
qi = 0
for i in range(len(r)):
    if ppick[pi] > qpick[qi] and qpick[qi] < r[i]:
        qpick[qi] = r[i]
        qi += 1
    elif ppick[pi] < qpick[qi] and ppick[pi] < r[i]:
        ppick[pi] = r[i]
        pi += 1
    else:
        break

print(sum(ppick) + sum(qpick))


### FIXED CODE ###

x,y,a,b,c = map(int,input().split())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
r = list(map(int,input().split()))

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

ppick = p[-x:]
qpick = q[-y:]
pi = 0
qi = 0

for i in range(len(r)):
    if pi >= x:
        while True:
            if qi < y and i < c and r[i] > qpick[qi]:
                qpick[qi] = r[i]
                qi += 1
                i += 1
            else:
                break
    elif qi >= y:
        while True:
            if pi < x and i < c and r[i] > ppick[pi]:
                ppick[pi] = r[i]
                pi += 1
                i += 1
            else:
                break
    elif ppick[pi] >= qpick[qi] and qpick[qi] < r[i]:
        qpick[qi] = r[i]
        qi += 1
        continue
    elif ppick[pi] < qpick[qi] and ppick[pi] < r[i]:
        ppick[pi] = r[i]
        pi += 1
        continue
    break

print(sum(ppick) + sum(qpick))
a, b, k = map(int, input().split())
r = list(range(a, b + 1))
for i in sorted(set(r[:k]) | set(r[- k:])):
    print(i)

### FIXED CODE ###

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

if b - a < 2 * k:
    for i in range(a, b + 1):
        print(i)

else:
    ans = []
    for i in range(k):
        ans.append(a + i)
    for i in range(k-1, -1, -1):
        ans.append(b - i)

    for i in ans:
        print(i)
N = input()
s = input()
hoge = []
charlist = list(s)
result = 1
Alist = ["q","w","e","r","t","y","u","i","o","p","a","s","d","f","g","h","j","k","l","z","x","c","v","b","n","m"]
for i in Alist:
    hoge.append(charlist.count(i))
for j in hoge:
    result = result * (j + 1)
print((result -1) ¥ (10 ** 9 + 7))


### FIXED CODE ###

N = input()
s = input()
hoge = []
charlist = list(s)
result = 1
Alist = ["q","w","e","r","t","y","u","i","o","p","a","s","d","f","g","h","j","k","l","z","x","c","v","b","n","m"]
for i in Alist:
    hoge.append(charlist.count(i))
for j in hoge:
    result = result * (j + 1)
print((result -1) % (10 ** 9 + 7))
x, y, z = [int(i) for i in input().split()]
x, y = y, x
x, z = z, x
print(f'{x} {y} {z}'

### FIXED CODE ###

x, y, z = [int(i) for i in input().split()]
x, y = y, x
x, z = z, x
print(x, y, z)
# -*- coding:utf-8 -*-
# https://atcoder.jp/contests/dp/tasks/dp_a
import math

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

dp = [math.inf]*N
dp[0] = 0
for i in range(1, N):
    cost1 = abs(h[i] - h[i-1])
    dp[i] = min(dp[i], dp[i-1] + cost1)
    if i > 1:
        cost2 = abs(h[i] - h[i - 2])
        dp[i] = min(dp[i], dp[i-2] + cost2)

print(dp[-1])






### FIXED CODE ###

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

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

dp = [float("inf")]*N
dp[0] = 0
for i in range(1, N):
    cost1 = abs(h[i] - h[i-1])
    dp[i] = min(dp[i], dp[i-1] + cost1)
    if i > 1:
        cost2 = abs(h[i] - h[i - 2])
        dp[i] = min(dp[i], dp[i-2] + cost2)

print(dp[-1])
a,b =input（）.split（）
c=int（a+b）
i=1
while True:
  if i *i ==c:
    print（"Yes"）
    exit（）
  elif i*i >c:
    print（"No"）
    exit（）
  else:
    i += 1
a,b = list（input（）.split（））
c=int（a+b）
i=1
while True:
  if i *i ==c:
    print（"Yes"）
    exit（）
  elif i*i >c:
    print（"No"）
    exit（）
  else:
    i += 1

### FIXED CODE ###

A,B=input().split()
A=int(A)
B=int(B)
if A*B%2==0 :
  print("Even")
else :
  print("Odd")
N, M = map(int, input().split())

broken_step = []
for _ in range(M):
    broken_step.append(int(input()))
    
mod = 1000000007

memo = [-1] * (N+1)

def step_memo(N):
    if N == 0:
        return 1
    if N == 1:
        return 1

    a = 1
    b = 1
    
    if N-1 in broken_step:
        a = 0
    if N-2 in broken_step:
        b = 0
    if N in broken_step:
        a = 0
        b = 0
        
    if memo[N] != -1:
        return memo[N]
    memo[N] =  (a * step_memo(N-1) + b * step_memo(N-2)) % mod
    return (a * step_memo(N-1) + b * step_memo(N-2)) % mod
  
print(step_memo(N))


### FIXED CODE ###

N, M = map(int, input().split())
import sys
sys.setrecursionlimit(10000000)

mod = 1000000007

memo = [-1] * (N+1)

for _ in range(M):
    broken_step = int(input())
    memo[broken_step] = 0
    
memo[0] = 1
if memo[1] == -1:
    memo[1] = 1

def step_memo(N):
    
    if memo[N] != -1:
        return memo[N]
    
    memo[N] =  (step_memo(N-1) + step_memo(N-2)) % mod
    return (step_memo(N-1) + step_memo(N-2)) % mod
  
print(step_memo(N))
n=int(input())
a=set(map(int,input().split()))
print("YES") if len(a)==n else print("NO")

### FIXED CODE ###

s,t=input().split()
a,b=map(int,input().split())
u=input()
print(a-1, b) if u==s else print(a, b-1)
import sys

N = int(sys.stdin.readline())
Ns = list(range(1, N + 1))
Ps = list(Ns[i + 1] for i in range(0, N - 1))
Ps.extend([Ns[0]])
#print(Ns)
#print(Ps)
mod_sum = sum(Ns[i] % Ps[i] for i in range(len(Ns)))
print(mod_sum)
#print()


### FIXED CODE ###

import sys

N = int(sys.stdin.readline())
print(int((N - 1) * N // 2))
s = input()
old = ''
flag = 0
sample = [chr(i) for i in range(97, 97+26)]
if len(s) == 26:
    if s == sample[::-1]:
        out = -1
    else:
        for i, s1 in enumerate(s[::-1]):
            if i != 0 and s1 < old[-1]:
                out = s[:len(s)-i-1] + min(old)
                break
            old += s1
else:
    for i1, i2 in zip(sorted(s), sample):
        if i1 != i2:
            out = s + i2
            flag = 1
            break
    if flag != 1:
        out = s + sample[len(s)]

print(out)

### FIXED CODE ###

s = input()
t = set(map(chr, range(ord('a'), ord('z')+1))) - set(s)
if t:
    print(s + min(t))
else:
    u = {s[-1]}
    for i in range(len(s)-1)[::-1]:
        x = [c for c in u if s[i]<c]
        if x:
            print(s[:i] + min(x))
            break
        u.add(s[i])
    else:
        print(-1)
N = int(input())
n = "three"

for i in (N):
  S = input().split()
  If S == "Y":
    n = "four"
    break
print(n)
    

  

### FIXED CODE ###

N = int(input())
number = "Three"
S = input().split()

for i in range(N):
  if S[i] == "Y":
    number = "Four"
    break

print(number)
A, B, C, D, E, F = map(int, input().split())

maxStrength = 0
ansMass = 100*A
ansSugar = 0
for i in range(100*A, F+1, 100*A):
        for j in range(0, F-i+1, 100*B):
                for k in range(0, F-i-j+1, C):
                        for l in range(0, F-i-j-k+1, D):
                                a = i + j
                                b = k + l
                                mass = a + b
                                if (a / 100)*E >= b and mass <= F and mass != 0:
                                        strength = (100*b) / mass
                                        if strength > maxStrength:
                                                maxStrength = strength
                                                ansMass = mass
                                                ansSugar = b

print(ansMass, ansSugar)


### FIXED CODE ###

n = int(input())
a = int(input())

print(n**2 - a)
N, M, K = map(int, input().split())
tree = [[] for i in range(N)]
block  = [[] for i in range(N)]
frends_cand = [set() for i in range(N)]

for i in range(M):
    a,b = map(int, input().split())
    tree[a-1].append(b-1)
    tree[b-1].append(a-1)
        
for i in range(K):
    a,b = map(int, input().split())
    block[a-1].append(b-1)
    block[b-1].append(a-1)

not_visited = set([i for i in range(N)])

visited = set()
def dfs(now):
    global visited
    visited.add(now)
    if  len(tree[now]) ==0:
        return print(now)
    else:
        next_tree  = set(tree[now]) - visited#有向であればtree[now]でok
        for i in next_tree:
            dfs(i)

while len(not_visited) !=0:
    visited = set()
    next_start = not_visited.pop()
    dfs(next_start)
    not_visited = not_visited - visited
    for i in visited:
        frends_cand[i] = visited

ans = ""        
for index, cand in enumerate(frends_cand):
    friend_cand = cand - set(block[index]) - set(tree[index])
    ans +=str(len(friend_cand)-1) + ' '
print(ans.strip())

### FIXED CODE ###

class UnionFind:
    def __init__(self, n):
        self.par = [i for i in range(n)]
        self.rank = [0] * (n)

    # 検索
    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    # 併合
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if self.rank[x] < self.rank[y]:
            self.par[x] = y
        else:
            self.par[y] = x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1

    # 同じ集合に属するか判定
    def same_check(self, x, y):
        return self.find(x) == self.find(y)

n,m,k=map(int,input().split())
friends_cand = UnionFind(n)
not_cand = [0 for i in range(n)]

for i in range(m):
    a,b = map(int, input().split())
    a, b = a-1, b-1
    friends_cand.union(a,b)
    not_cand[a] +=1
    not_cand[b] +=1
for i in range(k):
    c,d = map(int, input().split())
    c, d = c-1, d-1
    if friends_cand.find(c) == friends_cand.find(d):
        not_cand[c] +=1
        not_cand[d] +=1

size = [0 for i in range(n)]
for i in range(n):
    size[friends_cand.find(i)]+=1

ans = []
for i in range(n):
    ans.append(size[friends_cand.find(i)] - not_cand[i] - 1)
print(*ans)
import sys
N,K=map(int, input().split())
a=list(map(int, input().split()))
sum=0
for i in range(0,N):
  sum+=a[i]
if sum<K:#全部不必要
  print(N)
  sys.exit()
if sum==K:#全部必要
  print(0)
  sys.exit()
a.sort()
a.reverse()

#K未満の最大の数字のラベルはどこ？
l=N
for i in range(N-1,-1,-1):
  if a[i]<K:
    l=i
  else:
    break

if l==N:
  print(N)
  sys.exit()

count=N
#lまでの要素が必要か不要かチェック
for i in range(0,l):
  sum=0
  for j in range(l,N):
    if sum+a[j]<K:
      sum+=a[j]
  if sum+a[i]>=K:#必要ってことだ
    count-=1
#lからの要素は自分のことを抜かないといけないことに注意
for i in range(l,N):
  sum=0
  b=a[:]
  C=b.pop(i)
  for j in range(l-1,N-1):
    if sum+b[j]<K:
      sum+=b[j]
  if sum+C>=K:#必要ってことだ
    count-=1
print(count)

### FIXED CODE ###

a,b=map(str, input().split())
if a==b:
  print("H")
else:
  print("D")
A=int(input())
B=int(input())

print((A-1)*(B-1))

### FIXED CODE ###

a,b =map(int, input().split())
print((a-1)*(b-1))
M, N= input().split()
A1, Am = input().split()
if 1 <= int(N) < 10**6 and 1 <= int(M) < 10**4 and 1 <= int(A1) < 10**4 :
    if((int(A1) + int(Am)) <= int(M)):
        print((int(A1)+int(Am))-int(M))
    elif (int(A1) + int(Am)) == int(M):
        print(0)
    elif (int(A1)+int(Am)) > int(M):
        print(-1)

### FIXED CODE ###

M, N = map(int ,input().split())
x = [int(x) for x in input().split()]
if (sum(x)) > M:
    print(-1)
elif(sum(x) == M):
    print(0)
elif(sum(x)<M):
    print(M-sum(x))
import sys
n, a, b = map(int, input().split())
if (a + b) * (10**100) <= n:
    print(a * (10**100))
    sys.exit()
else:
    for i in range(n):
        if (a + b) * i <= n < (a + b) * (i + 1):
            j = i
            break
if n - (a + b) * j >= a:
    print(a * j + a)
    sys.exit()
else:
    print(a * j +n-(a + b)*j )
    sys.exit()

### FIXED CODE ###

import sys
n, a, b = map(int, input().split())
if a == 0 or n == 0:
    print(0)
    sys.exit()
j = n //(a + b)

if n - (a + b) * j >= a:
    print(a * j + a)
    sys.exit()
else:
    print(a * j + n- (a + b)*j )
    sys.exit()
N = int(input)
isDiv = 'No'
for i in range(1, 10):
  if N % i == 0:
    isDiv = 'Yes'
    break
print(isDiv)

### FIXED CODE ###

N = int(input())
isDiv = 'No'
for i in range(1, 10):
  if N % i == 0:
    if N / i <= 9:
    	isDiv = 'Yes'
    	break
print(isDiv)
N = int(input())
D = list(map(int, input().strip().split()))
D.sort()
# print(D)
 
def calc(arr):
  if arr[0] != 0:
    return 0
  result = 1
  curCount = 1
  preCount = 1
  for i in range(1, len(arr)):
    if arr[i] == 0:
      return 0
    if arr[i] == arr[i-1]:
      curCount += 1
    elif arr[i] == arr[i-1] + 1:
      preCount = curCount
      curCount = 1
    else:
      return 0
    result = result * preCount
    if result > 998244353:
      result = result % 998244353
    #print(pre, curCount, preCount, result)
  return result%998244353
 
print(calc(D))


### FIXED CODE ###

N = int(input())
half = 0
if N % 2 == 0:
  half = N//2-1
else:
  half = N//2
print(half)
N, M = [int(i) for i in input().split()]

if (N == M):
    print(Yes)
else:
    print(No)

### FIXED CODE ###

N, M = [int(i) for i in input().split()]

if (N == M):
    print('Yes')
else:
    print('No')
N = int(input())
Al = input().split()

A = range(N)
for i in range(Al):
  A[i] = int(i)

num = 0

for i in range(N):
  for j in range(i+1, N):
    num += A[i]*A[j]

num = num % (10**9 + 7)
print(num)

### FIXED CODE ###

N = int(input())
Al = input().split()
A = list( map((lambda x: int(x)), Al))
num = 0
ma = 10**9 + 7
li = 0

for i in range(N-1, 0, -1):
  li += A[i]
  num += A[i-1] * li

num = num % ma
print(num)
li_a = list(map(int,input().split()))
li_b = list(map(int,input().split()))
li_c = list(map(int,input().split()))
n = int(input())
li_num=[int(input()) for i in range(n)]

li_card = [li_a, li_b, li_c]

ans = False

#print(li_card)
#print(li_b)
#print(li_c)
#print(n)
#print(li_num)

for m in li_num:
    for i in range(3):
        for j in range(3):
          if li_card[i][j] == m:
              li_card[i][j] = 0

#print(li_card)

for i in range(3):
    if li_card[i][0] == li_card[i][1] == li_card[i][2]:
        ans = True
        break
    elif li_card[0][i] == li_card[1][i] == li_card[2][i]:
        ans = True
        break

if not ans:
  if li_card[0][0] == li_card[1][1] == li_card[2][2]:
      ans = True
  elif li_card[0][2] == li_card[1][1] == licard[2][0]:
      ans = True

if ans:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

li_a = list(map(int,input().split()))
li_b = list(map(int,input().split()))
li_c = list(map(int,input().split()))
n = int(input())
li_num=[int(input()) for i in range(n)]
 
li_card = [li_a, li_b, li_c]
 
ans = False
 
#print(li_card)
#print(li_b)
#print(li_c)
#print(n)
#print(li_num)
 
for m in li_num:
    for i in range(3):
        for j in range(3):
          if li_card[i][j] == m:
              li_card[i][j] = 0
 
for i in range(3):
    if li_card[i][0] == li_card[i][1] == li_card[i][2] == 0:
        ans = True
        break
    elif li_card[0][i] == li_card[1][i] == li_card[2][i] == 0:
        ans = True
        break
 
if not ans:
  if li_card[0][0] == li_card[1][1] == li_card[2][2] == 0:
      ans = True
  elif li_card[0][2] == li_card[1][1] == li_card[2][0] == 0:
      ans = True
 
if ans:
  print("Yes")
else:
  print("No")