peterverebics/CodeNet_Python_428 huggingface dataset:
# Judge status: Accepted
A, B, C = list(map(int, input().split()))
[A, B, C].sort() #smaller~bigger
if A==B and B==C:
    if A%2==0:
        print(-1)
    else:
        print(0)
elif (A%2==1) or (B%2==1) or (C%2==1):
    print(0)
else:
    cnt = 0
    while ((A%2==0) and (B%2==0) and (C%2==0)):
        [A, B, C] = [(A+B)/2, (A+C)/2, (B+C)/2]
        cnt += 1
    print(cnt)
# Judge status: Wrong Answer
n = int(input())
A = list(map(int, input().split()))[::-1]
ans = []
for i in range(n-1,-1,-1):
    t = A[i]
    for j in range(2*i+1,n+1,i+1):
        if i<j<n:
            t += A[j]
    if t%2!=A[i]:
        ans.append(i+1)
print(len(ans))
if len(ans)>0:
    print(*ans)
# Judge status: Accepted
from math import *

def aaa(n):
  return int((sqrt(8*n+1)-1)/2)

def bk(n):
  if n <= 1:
    return {}
  r = {}
  for i in range(2, ceil(sqrt(n))+1):
    if n % i != 0:
      continue
    r.setdefault(i,0)
    while n % i == 0:
      n //= i
      r[i] += 1
    if n == 1:
      return r
  r.setdefault(n, 1)
  return r

n = int(input())
f = bk(n)
print(sum((aaa(m) for m in f.values())))
# Judge status: Wrong Answer
from collections import Counter
c = Counter(list(input())).values()
print(2 * min(c))
# Judge status: Wrong Answer
from itertools import permutations

n = int(input())
nums = list(map(int, input().split()))

temp = dict(map(lambda x: (x, x[0] % x[1]), permutations(set(nums), 2)))
not_ans = set(map(lambda x: x[0], filter(lambda x: temp[x] == 0, temp)))

ans = list(filter(lambda x: not x in not_ans, nums))

print(len(ans))
# Judge status: Wrong Answer
import math
num = int(input())
syou = math.floor(num/15)
amari = num % 15
sum = 0

list = [1,2,0,4,0,0,7,8,0,0,11,0,13,14,0]
if syou >=1:
    sum += 60 + 120* (syou-1)

    for i in range(amari):
        sum += list[amari-1] + 15 * (syou-1)

    print(sum)

else:
    for d in range(num):
        sum += list[d]
    print(sum)
# Judge status: Accepted
x = input()
print("Yes" if x[0] == x[1] == x[2] or x[1] == x[2] == x[3] or x[0] == x[1] == x[2] == x[3] else "No")
# Judge status: Wrong Answer
N = int(input())
xy=[]
try :
  while True:
    t = input().split()
    t = list(map(int,t))
    xy.append(t)
except EOFError:
  pass
loc = [0,0]
time = 0
for i in range(N):
  a = xy[i]
  time = a[0]-time
  dis = abs(loc[0]-a[1])+abs(loc[1]-a[2])
  if (time-dis)<0 :
    print("No")
    break
  elif (time-dis)%2 == 0:
    pass
    
  else :
    print("No")
    break
  loc = [a[1],a[2]]
else :
  print("Yes")
# Judge status: Wrong Answer
line = list(input().split("/"))
print(line)
if int(line[0]) <= 2019 and int(line[1]) <= 4:
    print("Heisei") 
else:
    print("TBD")
# Judge status: Accepted
import sys
import numpy as np
import math
def Ii():return int(sys.stdin.readline())
def Mi():return map(int,sys.stdin.readline().split())
def Li():return list(map(int,sys.stdin.readline().split()))
n,k = Mi()
a = np.array(sys.stdin.readline().split(), np.int64)
maxa = np.max(a)
mina = maxa//(k+1)
while maxa > mina+1:
  mid = (mina+maxa)//2
  div = np.sum(np.ceil(a/mid-1))
  if div > k:
    mina = mid
  else:
    maxa = mid
  
print(maxa)
# Judge status: Accepted
n = int(input())
print(n * 800 - (n//15*200))
# Judge status: Wrong Answer
n=int(input())
print('Yes') if n%4==0 or n%7==0 or n%11==0 else print('No')
# Judge status: Accepted
N, K = map(int, input().split())
a = abs(N - (N // K) * K)
b = abs(a - K)
print(min(a, b))
# Judge status: Wrong Answer
from collections import Counter
N = int(input())
cnt = Counter(map(int, input().split()))

L = sum([[1] for a, c in cnt.items()], [])
L.sort()

ans = 0 if len(L) < 2 else L[-1] * L[-2]
print(ans)
# Judge status: Accepted
A=list("keyence")
f=-1;p=0
S=list(map(str,input()))
if S[0:7]==A or S[len(S)-7:len(S)]==A:
  f=1
else:
  if S[0]!=A[0]:
    f=0
  else:    
    for i in range(len(S)):
      if S[i]==A[i]:
        p=p+1
      else:
        if A[0:p]+S[len(S)-(len(A)-p):len(S)]==A:
          f=1
          break
        else:
          f=0
          break
print("YES" if f==1 else "NO")
# Judge status: Accepted
a = list(input())
if a[:(len(a)-1)//2] == a[((len(a)+3)//2)-1:] and a[:(len(a)-1)//2] == a[::-1][:(len(a)-1)//2]:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
s = [input() for _ in range(3)]
d = {"a": 0, "b": 1, "c": 2}
i = [-1] * 3
t = 0
while True:
    i[t] += 1
    if i[t] >= len(s[t]):
        break
    t = d[s[t][i[t]]]
print(["A", "B", "C"][t])
# Judge status: Wrong Answer
n = int(input())
data = [int(input()) for i in range(n)]
count = 1
temp = data[0]
for i in range(n):
    temp = data[temp-1]
    count += 1
    if temp == 2:
        print(count)
        break
else:
    print(-1)
# Judge status: Accepted
s=input()
if int(s[:4])<2019:
    print("Heisei")
    print("3")
elif int(s[:4])>2019:
    print("TBD")
elif int(s[5])==1 or int(s[6])>4:
    print("TBD")
else:
    print("Heisei")
# Judge status: Accepted
from numpy.linalg import solve
def C(n, r, MOD):
    num = 1
    den = 1
    for i in range(r):
        num *= n - i
        num %= MOD
        den *= i + 1
        den %= MOD
    return ((num * pow(den, MOD - 2, MOD)) % MOD)

X, Y = map(int, input().split())
MOD = 1_000_000_007
A = [[1, 2],[2, 1]]
B = [X, Y]
n, m = solve(A, B)
if n >= 0 and m >= 0 and n == int(n):
    n = int(n)
    m = int(m)
    print(C(n + m, n, MOD))
else:
    print(0)
# Judge status: Accepted
n,x,*l=map(int,open(0).read().split())
from math import *
a=0
for i in l: a=gcd(a,abs(i-x))
print(a)
# Judge status: Accepted
N, M = map(int, input().split())
X = list(map(int, input().split()))

X.sort()
diff = [0]*(M-1)
for i in range(M-1):
    diff[i] = X[i+1]-X[i]

diff.sort()
if N>=M:
    ans = 0
else:
    ans = sum(diff[:M-N])
print(ans)
# Judge status: Wrong Answer
s=int(input())
G =[s]
while all(G[i]!=G[-1] for i in range(len(G))):
  if G[-1] % 2==0:
    s == int(s/2)
    G.append(s)
  else:
    s == int(3*s+1)
    G.append(s)
print(len(G))
# Judge status: Accepted
n, k = map(int, input().split())
a = [int(x) for x in input().split()]
idx = k
r = 1
while idx < n:
    idx += k - 1
    r += 1
print(r)
# Judge status: Wrong Answer
a, b, n = map(int, input().split())

x = max(b-1, n)

print((a*x)//b)
# Judge status: Accepted
a=int(input())
if a%2==0:
  print(1/2)
else:
  print(((a+1)/2)/a)
# Judge status: Wrong Answer
N = int(input())
A = list(map(int, input().split()))
M = 1000
stock = 0
for i in range(1, N):
  # print(M)
  if A[i-1] < A[i]:
    stock = M // A[i-1]
    M -= stock * A[i-1]
  elif A[i-1] > A[i]:
    M += stock * A[i-1]
    stock = 0
if stock:
  M += stock * A[-1]
print(M)
# Judge status: Accepted
h,a=map(int,input().split())
ans=h//a
if h%a!=0:
    ans+=1
print(ans)
# Judge status: Accepted
from collections import Counter
s1 = sorted(list(dict(Counter(input())).values()))
t1 = sorted(list(dict(Counter(input())).values()))
print(['No', 'Yes'][s1 == t1])
# Judge status: Accepted
import sys
def S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())

n,c,k = MI()
t = sorted([I() for _ in range(n)])

cnt = 1
b = 1
bt = t[0]+k
for i in range(1, n):
    if cnt == c or t[i] > bt:
        b += 1
        bt = t[i]+k
        cnt = 1
    else:
        cnt += 1
print(b)
# Judge status: Wrong Answer
import math
n,d = map(int,input().split())
ans = 0
for i in range(n):
    x,y = map(int,input().split())
    print(math.sqrt((x ** 2) + (y ** 2)))
    if math.sqrt((x ** 2) + (y ** 2)) <= d:
        ans += 1
print(ans)
# Judge status: Wrong Answer
N=int(input())
a=list(map(int,input().split()))
a.sort()
a.append(0)
ans=0
b=0
c=0
for i in range(N+1):
  if b!=a[i]:
    if c<b:
      ans+=min((b-c),c)
    b=a[i]
    c=1
  else:
    if c==b:
      ans+=1
    else:
      c+=1
print(ans)
# Judge status: Accepted
X=int(input())
i=1
while X>0:
    X=X-i
    i=i+1
print(i-1)
# Judge status: Wrong Answer
n,x,y=map(int,input().split())

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

for i in range(1,n+1):
  for j in range(i+1,n+1):
    l=min(j-i,abs(x-i)+abs(y-j)+y-x)
    cnt[l] += 1
      
for i in range(1,n):
  print(cnt[i])
# Judge status: Wrong Answer
n, k = map(int, input().split())
s = set()
for _ in range(k):
    input()
    s.add(map(int, input().split()))
print(n - len(s))
# Judge status: Accepted
ab=list(map(int,input().split()))
i=max(ab)
while True:
  if i%ab[0]==0 and i%ab[1]==0:
    print(i)
    break
  i+=max(ab)
  #print(i)
# Judge status: Accepted
import sys
s=list(map(str,input()))
for i in range(len(s)):
    if i%2==0 and s[i]=='L':
        print('No')
        sys.exit()
    else:
        if i%2==1 and s[i]=='R':
            print('No')
            sys.exit()
print('Yes')
# Judge status: Accepted
a, b, c = map(int, input().split())
print('Yes' if a<=c<=b else 'No')
# Judge status: Accepted
N,K=map(int,input().split())
p=list(map(int,input().split()))
ans=0
temp=0
for i in range(K):
    temp+=(1+p[i])/2
ans=temp
for j in range(N-K):
    temp=temp-(1+p[j])/2+(1+p[j+K])/2
    if temp>ans:
        ans=temp
print(ans)
# Judge status: Accepted
import heapq
n, m = (int(x) for x in input().split())
A = [-int(x) for x in input().split()]
heapq.heapify(A)
for i in range(m):
  a = (-1)*heapq.heappop(A)
  a //= 2
  heapq.heappush(A, -a)
print(-sum(A))
# Judge status: Wrong Answer
x = int(input())
if x == 1:
    print("1")
else:
    print("0")
# Judge status: Accepted
A, B, C = [int(n) for n in input().split()]
print(C if A*C <= B else B//A)
# Judge status: Accepted
A = int(input())

print('ABC' if A < 1000 else 'ABD')
# Judge status: Accepted
def resolve():
    A = int(input())
    B = int(input())
    cands = set([1,2,3])
    print(list(cands-set([A, B]))[0])

if '__main__' == __name__:
    resolve()
# Judge status: Wrong Answer
s = list(input())
n = len(s)
s.append('0')
t = '0'
p = 0
i = 0
while i < n:
    if t == s[i]:
        t = s[i+1]
        i += 2
    else:
        t = s[i]
        i += 1
    p += 1
print(p)
# Judge status: Accepted
a, b, c, k = map(int, input().split())
if k == 0:
    print(a - b)
else:
    a, b, c = b + c, a + c, a + b 
    if a - b <= 0:
        print(abs(a - b) * (-1) ** k)
    
    elif a - b > 0:
        print(abs(a - b) * (-1) ** (k - 1))
# Judge status: Wrong Answer
color = input()

kosuu = input()

trashc = input()

_ = 0

color = color.split()
kosuu = kosuu.split()
trashc = trashc.split()


while True:
  if(trashc[0] == color[_]):
    kosuu[_] = int(kosuu[_]) -1
    break
      
  _= _+1
    
print(kosuu)
# Judge status: Accepted
N = int(input())
S = input()
count = S.count("R") * S.count("G") * S.count("B")


for j in range(N):
    for i in range(j):
        k = 2 * j - i
        if k >= N:
            continue
        if (S[i] != S[j]) and (S[i] != S[k]) and (S[j] != S[k]):
            count -= 1
print(count)
# Judge status: Accepted
n = int(input())

l = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

def moji(mes, layer, lim):
    if(layer==n):
        print(mes)
        return
    for i in range(lim+1):
        moji(mes+l[i], layer+1, max(lim,i+1))
    return

moji("", 0, 0)
# Judge status: Accepted
# -*- coding: utf-8 -*-

def rec(x):
    if x == 1:
        return 1

    return 2 * rec(x // 2) + 1


def main():
    from sys import setrecursionlimit

    setrecursionlimit(10 ** 7)

    n = int(input())
    print(rec(n))


if __name__ == '__main__':
    main()
# Judge status: Accepted
n,k=map(int,input().split())
i=0
while k**i<=n:
  i+=1
print(i)
# Judge status: Accepted
X,Y = map(int,input().split())
if((-X+2*Y)%3 != 0 or (-Y+2*X)%3 != 0 or -X+2*Y<0 or -Y+2*X<0):
    print(0)
    exit()
A = (-X+2*Y)//3
B = (-Y+2*X)//3
mod = 10**9+7
def combinations_count(A,B):
    bunsi,bunbo = 1,1
    for i in range(1,A+1):
        bunsi = (bunsi*(B+i))%mod
        bunbo = (bunbo*i) % mod
    return (bunsi*pow(bunbo,mod-2,mod))%mod
ans = combinations_count(A,B)
print(ans)
# Judge status: Wrong Answer
A, B = map(str, input().split())
A = int(A)
B = float(B)
Ax = A // 100
Ay = A % 100
Bx = B // 1
By = int((B - Bx) * 100)
p = Ax * Bx * 100 + Ax * By + Ay * Bx
q = (Ay * By) // 100
print(int(p + q))
# Judge status: Accepted
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
    n=int(input())
    print(0,0,10**9,1,-10**9*(-n//10**9)-n,-(-n//10**9))
if __name__=='__main__':
    main()
# Judge status: Wrong Answer
N, M = map(int, input().split())
s = {1}
t = [1]*N
res = 0
for _ in range(M):
    x, y = map(int, input().split())
    t[x-1] -= 1
    t[y-1] += 1
    if x-1 in s:
        s.add(y-1)
for i in range(N):
    if t[i] >= 1 and i in s:
        res += 1
print(res)
# Judge status: Accepted
n = int(input())
ans = 0
if n % 2 != 0:
    print(0)
    exit()
denominator = 10
while n >= denominator:
    ans += n//denominator
    denominator *= 5

print(ans)
# Judge status: Accepted
n = int(input())
s = str(input())
ans = 0
ans_lis = [0]

for i in range(n):
    if s[i] == "I":
        ans += 1
        ans_lis.append(ans)
    else:
        ans -= 1
        ans_lis.append(ans)

print(max(ans_lis))
# Judge status: Accepted
w,h,n = map(int,input().split())
x_max = w
x_min = 0
y_max = h
y_min = 0
for i in range(n):
    x,y,a = map(int,input().split())
    if a == 1:
        x_min = max(x_min,x)
    elif a == 2:
        x_max = min(x_max,x)
    elif a == 3:
        y_min = max(y_min,y)
    elif a == 4:
        y_max = min(y_max,y)
    #print(x_max,x_min,y_max,y_min)
a= max(x_max-x_min,0) 
b =max(y_max-y_min,0)
print(a*b)
# Judge status: Accepted
x,y,z=map(int,input().split())
a=x//(y+z)
if x-a*(y+z)>=z:
  print(a)
else:
  print(max(0,a-1))
# Judge status: Accepted
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline    ####
int1 = lambda x: int(x) - 1
def II(): return int(input())

def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())

def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]

INF = float('inf')

from math import pi
def solve():
    r = II()
    print(2 * pi * r)


if __name__ == '__main__':
    solve()
# Judge status: Wrong Answer
N,T = map(int,input().split())
mn = 10**10
for i in range(N):
    c,t = map(int,input().split())
    if t <= T and c < mn:
        mn = c
if mn == 10**10:
    print("TLE")
else:
    print(c)
# Judge status: Wrong Answer
x = int(input())
import math
for A in range(-10**5,10**5):
    A5 = A ** 5
    if x - A5 < 0:
        B = -1 *round(math.pow(-(x - A5),1/5),0)
    else:
        B = round(math.pow(x - A5,1/5),0)
    if  A5 == x + int(B) ** 5:
        print(A,int(B))
        quit()
# Judge status: Accepted
a, b = map(int, input().split())
if abs(a-b) % 2 == 0:
    print((a+b)//2)
else:
    print("IMPOSSIBLE")
# Judge status: Accepted
N = int(input())
S = input()

if N % 2 == 1:
    result = 'No'
else:
    middle = N // 2
    if S[:middle] == S[middle:]:
        result = 'Yes'
    else:
        result = 'No'

print(result)
# Judge status: Wrong Answer
from collections import Counter
n=int(input())
w=Counter(input())
for i in range(n-1):
    w &=Counter(input())
ans=""
for i,j in w.items():
    ans +=i*j
print(ans)
# Judge status: Accepted
N=input()
def alpha2num(alpha):
    num=0
    for index, item in enumerate(list(alpha)):
        num += pow(26,len(alpha)-index-1)*(ord(item)-ord('A')+1)
    return num
S=alpha2num(N)+1
num2alpha = lambda c: chr(c+64)

print(num2alpha(S))
# Judge status: Wrong Answer
x,y = map(int,input().split())
z = x
j = 1

while z < y:
    z += x ** j
    j += 1

if z == y:
    print(j+1)
else:
    print(j)
# Judge status: Accepted
n,m = map(int,input().split())
a = [list(map(int,input().split())) for i in range(m)]
l,r = [list(i) for i in zip(*a)]
print(max(0,min(r)-max(l)+1))
# Judge status: Wrong Answer


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

if a <=c <=b:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
N = int(input())
A = sorted(list(map(int,input().split())),reverse=True)

print(sum(A[0::2])-sum(A[1::2]))
# Judge status: Accepted
f=lambda:map(int,input().split())
w,h,n=f()
v=g=0
for _ in range(n):
  x,y,a=f()
  if a==1: v=max(v,x)
  if a==2: w=min(w,x)
  if a==3: g=max(g,y)
  if a==4: h=min(h,y)
print(max(w-v,0)*max(h-g,0))
# Judge status: Accepted
a, b, c, d = map(int, input().split())

AB = abs(b - a)
BC = abs(c - b)
AC = abs(c - a)

if (AB <= d and BC <= d) or AC <= d:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
x = int(input())
if x==7 or x == 5 or x ==3:
  print("YES")
else:
  print("NO")
# Judge status: Wrong Answer
a , b =map(int,input().split())
#print(a,b)

if a < b :
    print(a*b)
else :
    print(b*a)
# Judge status: Wrong Answer
n = int(input())
s = [input() for i in range(n)]
m = int(input())
t = [input() for i in range(m)]
for i in range(n):
    ans = 0
    for j in range(n):
        if s[i] == s[j]:
            ans += 1
    for k in range(m):
        if s[i] == t[k]:
            ans -= 1
    ans = max(ans, 0)
print(ans)
# Judge status: Accepted
H1, M1, H2, M2, K = map(int,input().split())

print((H2*60 + M2)-(H1*60+M1)-K)
# Judge status: Accepted
n = int(input())
x, y = map(int, input().split())
p, m = [x+y]*2, [x-y]*2
for i in range(n-1):
    x, y = map(int, input().split())
    p = [min(p[0], x+y), max(p[1], x+y)]
    m = [min(m[0], x-y), max(m[1], x-y)]
print(max(p[1] - p[0], m[1] - m[0]))
# Judge status: Wrong Answer
N = int(input())
K = int(input())
X = int(input())
Y = int(input())
print(N*X + (N - K)*Y)
# Judge status: Wrong Answer
a,b,c,n = map(int, input().split())

x1 = a*((2**n)+2*((-1)**n))//3 + (b+c)*(2**n+(-1)**(n-1))//3
x2 = b*((2**n)+2*((-1)**n))//3 + (a+c)*(2**n+(-1)**(n-1))//3

if abs(x1-x2)>10**18:
    print('Unfair')
else:
    print(x1-x2)
# Judge status: Wrong Answer
x, y, z = map(int, input().split())
if y > z:
    print("delicious")
elif x - z + y >= 0:
    print("safe")
else:
    print("dangerous")
# Judge status: Wrong Answer
n,l=map(int,input().split())
s=[]
ss=''
for i in range(n):
	s.append(input())
s=sorted(s)
for i in range(n):
	ss+=s[i]
print(print)
# Judge status: Accepted
S = input()

list = ['hoge','SAT','FRI','THU','WED','TUE','MON','SUN'] 

print(list.index(S))
# Judge status: Accepted
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
bigger_a = bigger_b = 0
for a_, b_ in zip(a, b):
    if a_ > b_: bigger_a += a_ - b_
    if b_ > a_: bigger_b += (b_ - a_) // 2
if bigger_b >= bigger_a: print("Yes")
else: print("No")
# Judge status: Accepted
from fractions import gcd

n=int(input())
A=list(map(int,input().split()))
left=[0]*n
right=[0]*n

left[0]=A[0]
for i in range(1,n-1):
    left[i]=gcd(left[i-1],A[i])

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

ans=max(left[-2],right[1])
for i in range(1,n-1):
    ans=max(ans,gcd(left[i-1],right[i+1]))
print(ans)
# Judge status: Wrong Answer
s = input()
k = int(input())

print(s[0])
# Judge status: Accepted
n, m = map(int, input().split())
edges = [tuple(map(int, input().split())) for _ in range(m)]

c = [[] for _ in range(n + 1)]

for a, b in edges:
    c[a].append(b)
    c[b].append(a)

for i in range(1, n + 1):
    print(len(c[i]))
# Judge status: Wrong Answer
n,c,k = map(int, input().split())
t = [int(input()) for _ in range(n)]
t.sort()
x = ""
cnt = 0
ans = 0
for i in range(n):
  if x == "": x = t[i]+k
  if x > t[i]: cnt += 1
  else:
    cnt = 1
    ans += 1
    x = t[i]+k
  if cnt == c:
    cnt = 0
    ans += 1
    x = ""
  if i == n-1 and cnt != 0:
    ans += 1
print(ans)
# Judge status: Accepted
n = int(input())
a = list(map(int,input().split()))
now_number = 0

for i in range(n):
  if a[i] == now_number+1:
    now_number = a[i]

if now_number == 0:
  print(-1)
else:
  print(n - now_number)
# Judge status: Accepted
n = int(input())
l = [int(i) for i in input().split()]
l.sort()
print(l[n//2]-l[n//2-1])
# Judge status: Wrong Answer
a,b = map(int,input().split())
if (a * b) % 2 == 0:
  print("Even")
elif (a * b) % 2 == 1:
  print("0dd")
# Judge status: Accepted
h1,m1,h2,m2,k =[int(x) for x in input().split()]
minute = (h2*60+m2) - (h1*60+m1) - k
if minute <= 0:
    print(0)
else:
    print(minute)
# Judge status: Accepted
import heapq as hq


def resolve():
    N,M = map(int,input().split())
    AB = [list(map(int,input().split())) for i in range(N)]
    AB.sort()
    q=[]
    sm =0
    counter =0
    for i in range(1,M+1):
        while counter <N and AB[counter][0]<=i:
            hq.heappush(q,-AB[counter][1])
            counter += 1

        if not q:
            continue
        sm -= hq.heappop(q)
    print(sm)


    

if __name__ == "__main__":
    resolve()
# Judge status: Accepted
A,B,M = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
ans = 1e9
for i in range(M):
    x,y,c = map(int,input().split())
    wari = max(a[x-1]+b[y-1]-c,0)
    ans = min(ans,wari)
ans = min(ans,min(a)+min(b))
print(ans)
# Judge status: Accepted
N=int(input())
H=list(map(int,input().split()))

ans=0
sum=0
for i in range(N-1):
    if H[i]>=H[i+1]:
        sum += 1
    else:
        sum = 0
    ans = max(ans,sum)
print(ans)
# Judge status: Wrong Answer
a, b, c = map(int, input().split())
if b>c:
  print(b)
else:
  print(a*c)
# Judge status: Accepted
s=input()
res = ''
if 'N' in s:
    if 'S' not in s:
        res = 'No'
if 'S' in s:
    if 'N' not in s:
        res = 'No'
if 'E' in s:
    if 'W' not in s:
        res = 'No'
if 'W' in s:
    if 'E' not in s:
        res = 'No'
if res == '':
    print('Yes')
else:
    print(res)
# Judge status: Accepted
n = int(input())
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
total = sum(a2)+a1[0]
ans = sum(a2)+a1[0]
for i in range(1, n):
    total += a1[i] - a2[i-1]
    if ans < total:
        ans = total
print(ans)
# Judge status: Wrong Answer
x = int(input())

if x>=30:
    print('YES')
else:
    print('NO')
# Judge status: Accepted
N = int(input())
li = []
pre_t = 0
pre_x = 0
pre_y = 0
ans = "Yes"
for _ in range(N):
    t, x, y = map(int, input().split())
    dist = abs(x - pre_x) + abs(y - pre_y)
    d_t = abs(t - pre_t)
    if dist > d_t or (dist - d_t) % 2 == 1:
        ans = "No"

    pre_t, pre_x, pre_y = t, x, y

print(ans)
# Judge status: Accepted
N=int(input())
shop=[]
for i in range(N):
    S,P=input().split()
    P=int(P)
    shop.append([S,100-P,i])
shop.sort()
for i in range(N):
    print(shop[i][2]+1)
# Judge status: Accepted
h1, m1, h2, m2, k=map(int, input().split())
wake_time = (h2-h1)*60 + m2 - m1
result = wake_time - k
print(result)
# Judge status: Accepted
A,B,X=map(int,input().split())
if A<=X<A+B:
    print('YES')
else:
    print('NO')
# Judge status: Wrong Answer
a,b,c,d=map(int,input().split())

if (a<=b<=a+d and b<=c<=b+d) or a<=c<=c+d:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
x,y = input().split()
q,w = input().split()
a =int(x)
b=int(y)
c= int(q)
d =int(w)
e =int(input())

if c-a >0:
  if c-a <=e*(b-d):
    print('YES')
   
  else:
    print('NO')
    
else:
  if a-c<=e*(b-d):
    print('YES')
   
  else:
    print('NO')
# Judge status: Accepted
import decimal
L = int(input())
ans = decimal.Decimal(L**3)/decimal.Decimal(27)
print(ans)
# Judge status: Accepted
N=int(input())
CARD={}
for i in range(N):
  s = str(input())
  if s not in CARD:
    CARD[s] = 1
  else:
    CARD[s]+=1
M=int(input())
for i in range(M):
  t = str(input())
  if t in CARD:
    CARD[t]-=1
print(max(max(CARD.values()),0))
# Judge status: Wrong Answer
a,b=map(int,input().split())
print("Negative" if b<0 and (-1)**((b-a+1)%2)<0 else 0 if a<=0 else "Positive")
# Judge status: Wrong Answer
x,y=input().split()
l=['1','3','5','7','8','10','12','4','6','9','11','2']
x_loc=l.index(x)
y_loc=l.index(y)

if x_loc==11 and y_loc==11:
    print('Yes')
elif x_loc<7 and y_loc<7:
    print('Yes')
elif x_loc>6 and x_loc<11 and y_loc>11 and y_loc>11:
    print('Yes')
else:
    print('No')
# Judge status: Accepted
n = int(input())
a = []
for i in range(n):
  a.append(int(input()))
b = a[0]
c = []
while True:
  if b == 2:
    print(len(c)+1)
    exit()
  if len(c)> n:
    print(-1)
    exit()
  else:
    c.append(b)
    b = a[c[-1]-1]
# Judge status: Accepted
#053_C
x = int(input())

if x % 11 == 0:
    ans = x // 11 * 2
else:
    ans = x // 11 * 2 + (x % 11 > 6) + 1
print(ans)