Harryxun/stf_run huggingface dataset:
from heapq import heappush, heappop
import sys

N,K = list(map(int, input().split(' ')))
d = {}
for i in range(N):
    S = str(input())[0]
    if S in d:
        d[S] += 1
    else:
        d[S] = 1
p = list(d.values())
if len(p) < K:
    print(0)
    sys.exit(1)


### FIXED CODE ###

import sys
N,K = list(map(int, input().split(' ')))
d = {}
for i in range(N):
    S = str(input())[0]
    if S in d:
        d[S] += 1
    else:
        d[S] = 1
p = list(d.values())
if len(p) < K:
    print(0)
    sys.exit()
c = 0
while(len(p) >= K):
    c += 1
    sq = sorted(p, reverse=True)
    for i in range(K):
        sq[i] = sq[i] - 1
    p = [i for i in sq if i != 0]
print(c)
s = input()
ans="Good"
for i in range(len(s)):
	if s[i]==s[i+1]:
		ans="Bad"
print(ans)

### FIXED CODE ###

s = input()

ans="Good"
for i in range(3):
	if s[i]==s[i+1]:
		ans="Bad"
print(ans)
a=list(input())
b=list(input())
c=list(input())
S=[a,b,c]
s=a
while True:
  s=S[s].pop()
print(s.upper())

### FIXED CODE ###

S={c:list(input()) for c in "abc"}
s="a"
while S[s]:s=S[s].pop(0)
print(s.upper())
n,m = map(n,m = map(int,input().split())
a = list(map(int,input().split()))

s = sum(a)
u = s / (4*m)
c = 0
for i in a:
    if i >= u: c += 1

if c >= m: print('Yes')
else : print('No')

### FIXED CODE ###

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

s = sum(a)
u = s / (4*m)
c = 0
for i in a:
    if i >= u: c += 1

if c >= m: print('Yes')
else : print('No')
from sys import stdin

def waru(a,b):
  if a%b != 0:
    return 0
  if a/b == 1:
    return b
  return waru(a/b,b)
  

def main():
  s = []
  read = stdin.readline
  N =int(read())
  i = 2
  table = []
  ap = table.append
  while i * i <= N:
    while N%i == 0:
      ap(i)
      N //= i
    i += 1
  if N > 1:
    ap(N)
  set_table = sorted(list(set(table)))
  kaisu = [0] * len(set_table)
  num = 0
  for i in table:
    if i == set_table[num]:
      kaisu[num] += 1
    else:
      num += 1
      kaisu[num] += 1
  maxk = max(kaisu)
  j = 1
  count = 0
  while j <= maxk:
    count += len([i for i in kaisu if i >= j])
    j = j + j + 1
  print(count)
    
      
      

  
  
  
if __name__ == "__main__":
  main()

### FIXED CODE ###

from sys import stdin

def waru(a,b):
  if a%b != 0:
    return 0
  if a/b == 1:
    return b
  return waru(a/b,b)
  

def main():
  s = []
  read = stdin.readline
  N =int(read())
  if N == 1:
    print(0)
    exit()
  i = 2
  table = []
  ap = table.append
  while i * i <= N:
    while N%i == 0:
      ap(i)
      N //= i
    i += 1
  if N > 1:
    ap(N)
  set_table = sorted(list(set(table)))
  kaisu = [0] * len(set_table)
  num = 0
  for i in table:
    if i == set_table[num]:
      kaisu[num] += 1
    else:
      num += 1
      kaisu[num] += 1
  maxk = max(kaisu)
  j = 1
  k = 0
  count = 0
  while j <= maxk:
    count += len([i for i in kaisu if i >= j])
    k += 1
    j = j + k + 1
  print(count)
    
      
      

  
  
  
if __name__ == "__main__":
  main()
a, b = input().split()
a = int(a)
b = int(b)

if b * 2 >= a:
  	print(0)
else:
  	s = a - b * 2  
    print(s)

### FIXED CODE ###

a, b = input().split()
a = int(a)
b = int(b)
 
ans = max(a-b*2, 0)
print(ans)
import sys

for index, line in sys.stdin():
    value = int(line.strip())
    print("Case {0}: {1}".format(index, value))

### FIXED CODE ###

import sys

for index, line in enumerate(sys.stdin):
    value = int(line.strip())
    if value == 0:
        break
    print("Case {0}: {1}".format(index+1, value))
import bisect
N, X = map(int, input().split())
x = sorted(list(map(int, input().split()))+[X])

i = bisect.bisect_left(x, X)
print(min(abs(x[i-1]-x[i]), abs(x[i]-x[i+1])))

### FIXED CODE ###

from fractions import gcd
N, X = map(int, input().split())
L = sorted(list(map(int, input().split())))

ans = abs(L[0]-X)
for x in L[1:]:
    ans = gcd(ans, abs(x-X))
print(ans)
for i in"_"*365:print(i%26+1)

### FIXED CODE ###

import sys
input = sys.stdin.readline

d = int(input())
C = tuple(map(int, input().split()))
S = tuple(tuple(map(int, input().split())) for _ in range(d))
ans = 0
R = [0]*26
for i in range(1, d+1):
  M = -float("inf")
  idx = -1
  for t in range(26):
    L = list(R)
    L[t] = i
    temp = S[i-1][t]
    for j, (c, l) in enumerate(zip(C, L)):
      temp -= c*(i-l)
    if M < temp:
      M = temp
      idx = t
  R[idx] = i
  print(idx+1)
#coding=UTF-8

def search(jun):
    global ans
    global R
    global rrCost
    tmpans=0
    if len(jun)==R:
        mae=jun[0]
        for idx in range(1,R,1):
            ba=jun[idx]
            tmpans += rrCost[mae][ba]
            mae=ba

        if ans==None or tmpans<ans:
            ans=tmpans
    else:
        for me in range(0,R,1):
            if not (me in jun):
                search(jun+[me])

mozir=input()
hyo=mozir.split(' ')
N=int(hyo[0])
M=int(hyo[1])
R=int(hyo[2])

mozir=input()
hyo=mozir.split(' ')
r=[(int(mono)-1) for mono in hyo]

michi=[]
for idx in range(0,M,1):
    mozir=input()
    hyo=mozir.split(' ')
    A=int(hyo[0])-1
    B=int(hyo[1])-1
    C=int(hyo[2])

    michi.append((A,B,C))
    michi.append((B,A,C))

rrCost=[]
for idx in range(0,R,1):
    rrCost.append([None]*R)

for idx in range(0,R,1):
    rrCost[idx][idx]=0

for idr in range(0,R,1):
    deCost=[None]*N
    deCost[r[idr]]=0
    
    miru=[]
    for mono in michi:
        if mono[0] == r[idr]:
            deCost[mono[1]]=mono[2]
            miru.append(mono[1])

    while miru:
        nextmiru=[]

        for me in miru:
            preCost=deCost[me]
            for mono in michi:
                if mono[0] == me:
                    tmpCost=preCost+mono[2]
                    if deCost[mono[1]]==None or deCost[mono[1]]>tmpCost:
                        deCost[mono[1]]=tmpCost
                        nextmiru.append(mono[2])

        miru=list(set(nextmiru))

    for idx in range(0,R,1):
        rrCost[idr][idx]=deCost[r[idx]]
        rrCost[idx][idr]=deCost[r[idx]]


ans=None
search([])
print(ans)


### FIXED CODE ###

#coding=UTF-8

def search(jun):
    global ans
    global R
    global r
    global rCost
    tmpans=0
    if len(jun)==R:
        mae=jun[0]
        for idx in range(1,R,1):
            ba=jun[idx]
            tmpans += rCost[mae][r[ba]]
            mae=ba

        if ans==None or tmpans<ans:
            ans=tmpans
    else:
        for me in range(0,R,1):
            if not (me in jun):
                search(jun+[me])


mozir=input()
hyo=mozir.split(' ')
N=int(hyo[0])
M=int(hyo[1])
R=int(hyo[2])

mozir=input()
hyo=mozir.split(' ')
r=[(int(mono) -1 ) for mono in hyo]

michi=[]
for idx in range(0,N,1):
    michi.append([])

for idx in range(0,M,1):
    mozir=input()
    hyo=mozir.split(' ')
    A=int(hyo[0])-1
    B=int(hyo[1])-1
    C=int(hyo[2])
    michi[A].append((B,C))
    michi[B].append((A,C))


rCost=[]
for idr in range(0,R,1):
    Cost=[None]*N
    Cost[r[idr]]=0
    miru=[r[idr]]
    while miru:
        nextmiru=[]
        for toshi in miru:
            preCost=Cost[toshi]
            for (saki,sakiCost) in michi[toshi]:
                tmpCost=preCost+sakiCost
                if Cost[saki]==None or tmpCost < Cost[saki]:
                    Cost[saki]=tmpCost
                    nextmiru.append(saki)

        miru=list(set(nextmiru))
    rCost.append(Cost)

#for ko in rCost:
#    print(ko)

ans=None
search([])
print(ans)
N = int(input())
A = list(map(int,input().split()))
 
ans = 'Yes'
for i in range(N-1, 0, -1):
  if A[i] > A[i-1]: A[i-1] -= 1
    if A[i] > A[i-1]:
      ans = 'No'
      break

print(ans)


### FIXED CODE ###

N = int(input())
A = list(map(int,input().split()))
 
# 左から順にやるとうまくいかない => [1, 4, 3, 2, 1] みたいな場で失敗
# 右から順に考えよ！
ans = 'Yes'
for i in range(N-1, 0, -1):
  if A[i] < A[i-1]: A[i-1] -= 1
  if A[i] < A[i-1]:
    ans = 'No'
    break

print(ans)
N,K = map(int,input())
li = [int(input()) for i in range(N)]
ans = 0
for i in li:
  if i >= K:
    ans += 1
print(ans)

### FIXED CODE ###

N,K = map(int,input().split())
li = list(map(int,input().split()))
ans = 0
for i in li:
  if i >= K:
    ans += 1
print(ans)
s=int(input())
e_list=dic(map(int,input().split()))
e_dic
for i in range(1,s+1):
  e_dic[i]=e_list.count(i)
 
for i in e_dic.keys():
  print(e_dic[i])

### FIXED CODE ###

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

ans=[0]*n

for i in l:
    ans[i-1]+=1

for j in ans:
    print(j)
import sys
input=sys.stdin.readline
n = int(input())
s = input()
N0 = 2**(n-1).bit_length()
INF = 2**31-1
data = [""]*(2*N0)
def update(k, x):
    k += N0-1
    data[k] = x
    while k >= 0:
        k = (k - 1) // 2
        data[k] = ope(data[2*k+1],data[2*k+2])
def query(l, r):
    L = l + N0; R = r + N0
    s = ""
    while L < R:
        if R & 1:
            R -= 1
            s = ope(s, data[R-1])

        if L & 1:
            s = ope(s,data[L-1])
            L += 1
        L >>= 1; R >>= 1
    return s
  
def ope(x, y):
    r = []
    if type(x) is str and type(y) is str:
        r = [x, y]
    elif type(x) is str:
        r = [x] + y
    elif type(y) is str:
        r = x + [y]
    else:
        r = x + y

    return list(set(r))

for i in range(len(s)):
    update(i,s[i])

quenum = int(input())
ans=[]
for i in range(quenum):
    que, a, b = input().split()

    if que == "1":
        update(int(a)-1,b)
    else:
        ans.append(str(len(query(int(a)-1,int(b)))-1))
print("\n".join(ans))

### FIXED CODE ###

n=int(input())
s=input()
q=int(input())

query=[]
for i in range(q):
    query.append(input())

ide_ele = set()

def segfunc(x, y):
    return x | y

class SegTree:
    def __init__(self, init_val, segfunc, ide_ele):
        n = len(init_val)
        self.segfunc = segfunc
        self.ide_ele = ide_ele
        self.num = 1 << (n - 1).bit_length()
        self.tree = [ide_ele] * 2 * self.num
        for i in range(n):
            self.tree[self.num + i] = init_val[i]
        for i in range(self.num - 1, 0, -1):
            self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])

    def update(self, k, x):
        # param k: index(0-index)
        # param x: update value
        k += self.num
        self.tree[k] = x
        while k > 1:
            self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
            k >>= 1
    def query(self, l, r):
        #[l, r)segfunc, 0-index
        res = self.ide_ele
        l += self.num
        r += self.num
        while l < r:
            if l & 1:
                res = self.segfunc(res, self.tree[l])
                l += 1
            if r & 1:
                res = self.segfunc(res, self.tree[r - 1])
            l >>= 1
            r >>= 1
        return res

al = [{s[i]} for i in range(n)]
seg = SegTree(al, segfunc, ide_ele)

for q in query:
    que,a,b=q.split()

    if que == "1":
        seg.update(int(a)-1,set(b))
    else:
        ret=seg.query(int(a)-1,int(b))
        print(len(ret))
n = int(input())
a = list(map(int, input().split()))
ans = [0] * (n+1)

i = n
while i > 0:
    cnt = 0
    for j in range(1, n+1):
        if i * j  > n+1:
            break
        cnt += ans[i*j]
    if cnt % 2 != a[i-1]:
        ans[i] = 1
    i -= 1
    #print(cnt)
print(ans.count(1))
for i in range(1,n+1):
    if ans[i] == 1:
        print(i)

### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
ans = [0] * (n+1)

i = n
while i > 0:
    cnt = 0
    for j in range(1, n+1):
        if i * j  > n:
            break
        cnt += ans[i*j]
    if cnt % 2 != a[i-1]:
        ans[i] = 1
    i -= 1
    #print(cnt)
print(ans.count(1))
for i in range(1,n+1):
    if ans[i] == 1:
        print(i)
N = int(input())
S = [input() for i in range(N)]
print(count(set(S)))

### FIXED CODE ###

N = int(input())
S = [input() for i in range(N)]
print(len(set(S)))
n = int(input())
INF = 10**9
P = [], []
for i in range(n):
    p = map(int, input().split())
    P.append()
m = [[0]*n for in range(n)]

for l in range(2, n + 1):
    for i in range(n - l + 1):
        j = i + l - 1
        m[i][j] = INF
        for k in range(i, j):
            m[i][j] = min(m[i][j], m[i][k] + m[k + 1]m[j] + p[i - 1] * p[k] * p[j])

print(m[0][n - 1])

### FIXED CODE ###

n = int(input())
INF = 10**9
P = [list(map(int, input().split())) for i in range(n)]
m = [[0]*n for i in range(n)]

for l in range(2, n + 1):
    for i in range(n - l + 1):
        j = i + l - 1
        m[i][j] = INF
        for k in range(i, j):
            m[i][j] = min(m[i][j], m[i][k] + m[k + 1][j] + P[i][0] * P[k][1] * P[j][1])

print(m[0][n - 1])
N = int(input())
A = input().split()
for i in range(len(A)):
    A[i] = int(A[i])
A.sort()

answer = A[0]
overl = False

for i in range(N-1):
    answer *= A[i+1]
    if answer > 10**18:
        overl = True
        break

if overl:
    print("-1")
else:
    print(answer)

### FIXED CODE ###

S = input().split()

A = int(S[0])
B = int(S[1])

print(A*B)
while True:
	x,y = map(int,raw_input().split())
	if x,y == 0,0:
		break
	elif x >= y:
		print x, y
	elif y >x:
		print y, x

### FIXED CODE ###

while True:
	x,y = sorted(map(int,raw_input().split()))
	if x==y==0:
		break
	print x,y
a,b=map(int,input().split())
import numpy as np
def gcd(x,y):
  if x%y==0:
    return y
  else:
    return gcd(x,x%y)
  
  
  
z=np.ceil(np.sqrt(gcd(a,b)))
j=0
ans=[]
for i in range(1,z+1):
  while z%i==0:
    z/=i
    ans.append(i)
  

  
print(len(ans))
    


### FIXED CODE ###

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

def gcd(x,y):
  if x%y==0:
    return y
  else:
    return gcd(y,x%y)
  
  
n=gcd(a,b)  
i=2
ans=[1]

while i * i <= n:
  if n % i == 0:
    n /= i
    ans.append(i)
  else:
    i += 1

ans.append(n)    
  
print(len(set(ans)))
n = int(input())
x = list(map(int, input().split()))
x = sorted(x)
ans=1
for i in a:
  ans *= i
  if ans > 10 ** 8:
    print(-1)
    exit()
print(ans)



### FIXED CODE ###

n = int(input())
a = sorted(map(int, input().split()))
ans = 1
for i in a:
    ans *= i
    if ans > 10 ** 18:
        print(-1)
        exit()
print(ans)
A,B,C = map(int,inputs().split())

if A + B + C == 17:
  if A + B or A + C or B + C == 10:
    print("YES")
  else:
    print("NO")
else:
  print("NO")

### FIXED CODE ###

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

if A + B + C == 17:
  if A + B or A + C or B + C == 10:
    print("YES")
  else:
    print("NO")
else:
  print("NO")
if v <= w:
    print("NO")
elif (b-a)%(v-w) == 0 and (b-a)//(v-w)+1 > t:
    print("NO")
elif -(-(b-a)//(v-w)) > t:
    print("NO") 
else:
    print("YES")

### FIXED CODE ###

a,v = map(int,input().split())
b,w = map(int,input().split())
t = int(input())

if v == w:
    print("NO")
else:
    if w > v:
        print("NO")
    else:
        if abs(b-a) / (v-w) <= t:    
            print("YES")
        else:
            print("NO")
l=list(map(int,input().split()))
n=l[0]
w=l[1]
va=[0]*n
wa=[0]*n
for i in range(n):
        
    x=list(map(int,input().split()))
    wa[i]=x[0]
    va[i]=x[1]
dp=[[0 for i in range(w+1)] for j in range(n+1)]
for i in range(1,n+1):
  for j in range(1,w+1):
    if wa[i-1]>j:
      dp[i][j]=dp[i-1][j]
    else:
      dp[i][j]=max(dp[i-1][j],dp[i-1][j-wa[i-1]]+va[i-1])
print(dp[-1][-1])


### FIXED CODE ###

n=int(input())
s=list(map(int,input().split()))
cost=[0]*n
cost[1]=abs(s[1]-s[0])
if n==2:
  
  print(abs(s[1]-s[0]))
  
else:
  for i in range(2,len(s)):
  	cost[i]=min(abs(s[i]-s[i-1])+cost[i-1],abs(s[i]-s[i-2])+cost[i-2])
  print(cost[n-1])
import sys
inputs = sys.stdin.readline
N, Q= map(int,inputs().split())
V = [None]*N
E = []
for n in range(N):
	V[n] = list(map(int,inputs().split()))
	V[n][0] -= V[n][2]
	V[n][1] -= V[n][2]
	E.append([V[n][0],1,V[n][2]])
	E.append([V[n][1],-1,V[n][2]])
D = [int(inputs()) for p in [0]*Q]
E.sort(key = lambda x:x[0])
mini = 1000000001
kouho = [1000000001]
q = 0
d = D[0]
for e in E:
	flag = 0
	if e[0] <= d:
		if  e[1] == 1:
			kouho.append(e[2])
		elif e[1] == -1:
			kouho.remove(e[2])
	if e[0] > d:
		for k in kouho:
			mini = min(k,mini)
		if mini < 1000000001:
			print(mini)
			mini = 1000000001
		else:
			print(-1)
			mini = 1000000001
		flag = 1
		if q < Q-1:
			q = q + 1
			d = D[q]
		else:
			break
	if e[0] <= d and flag == 1:
		if  e[1] == 1:
			kouho.append(e[2])
		elif e[1] == -1:
			kouho.remove(e[2])
for t in [None]*(Q-q):
	print(-1)

### FIXED CODE ###

import sys
input = sys.stdin.readline
a,p = map(int,input().split())
ans = (3*a + p)//2
print(ans)
N = int(input())
X = list(input())
X = [int(x) for x in X]
X.reverse()

def popcnt0(n):
    c = 0
    for i in range(64):
        c += (n >> i) & 1
    return c
  
#最初にNまでの表を作る
D = [0 for _ in range(N+1)]
D[1] = 1
for i in range(2, N+1):
  D[i] = D[i % popcnt0(i)] + 1
  
#次に、Xの１のカウントを求める
ct_1 = 0
for x in X:
  if x == 1:
    ct_1 += 1

#ct_1-1による2^n mod
B = [0 for _ in range(N)]
j = 1
for i in range(N):
  B[i] = j
  j *= 2
  j %= ct_1 - 1 
  
#ct_1+1による2^n mod
C = [0 for _ in range(N)]
j = 1
for i in range(N):
  C[i] = j
  j *= 2
  j %= ct_1 + 1 

#X mod ct_1-1 と、X mod ct_1+1 を求める
s = 0
t = 0
for i in range(N):
  s += X[i] * B[i]
  t += X[i] * C[i]
  s %= ct_1-1
  t %= ct_1+1

X.reverse()
#print(X)
#print(D,B,C)
i = N-1
#各場合の1回目の操作後の数を計算して、Dをつかって答えを出す
for x in X:
  if x == 1:
    k = (s - B[i]) % (ct_1-1)
  else:
    k = (t + C[i]) % (ct_1+1)
  i -= 1
  print(D[k]+1)
 

  
  
  

### FIXED CODE ###

N = int(input())
X = list(input())
X = [int(x) for x in X]
X.reverse()

def popcnt0(n):
    c = 0
    for i in range(64):
        c += (n >> i) & 1
    return c
  
#最初にNまでの表を作る
D = [0 for _ in range(N+1)]
D[1] = 1
for i in range(2, N+1):
  D[i] = D[i % popcnt0(i)] + 1
  
#次に、Xの１のカウントを求める
ct_1 = 0
for x in X:
  if x == 1:
    ct_1 += 1

#ct_1-1による2^n mod
if ct_1 > 1:
  B = [0 for _ in range(N)]
  j = 1
  for i in range(N):
    B[i] = j
    j *= 2
    j %= ct_1 - 1 


#ct_1+1による2^n mod
C = [0 for _ in range(N)]
j = 1
for i in range(N):
  C[i] = j
  j *= 2
  j %= ct_1 + 1 

#X mod ct_1-1 と、X mod ct_1+1 を求める
s = 0
t = 0
for i in range(N):
  if ct_1 > 1:
    s += X[i] * B[i]
    s %= ct_1-1
  t += X[i] * C[i] 
  t %= ct_1+1

X.reverse()
#print(X)
#print(D,B,C)
i = N-1
#各場合の1回目の操作後の数を計算して、Dをつかって答えを出す
for x in X:
  if x == 1:
    if ct_1 > 1:
      k = (s - B[i]) % (ct_1-1)
    else:
      print(0)
  else:
    k = (t + C[i]) % (ct_1+1)        
  i -= 1
  if ct_1 > 1 or x == 0:
    print(D[k]+1)
import sys
input = sys.stdin.readline
N = int(input())


node = [0 for i in range(N)]
neigh = [[] for j in range(N)]
ans = [0 for i in range(N)]
visited = [0 for i in range(N)]
k = 1

for i in range(N-1):
    ai,bi = map(int,input().split())
    node[ai-1] += 1
    node[bi-1] += 1
    neigh[ai-1].append(bi-1)
    neigh[bi-1].append(ai-1)
c = list(map(int,input().split()))
c.sort(reverse=True)

def dfs(neighbor,start,visited):
    global k
    global c
    if sum(visited) == N:
        return 0
    for i in neighbor[start]:
        if visited[i] == 0:
            ans[i] = c[k]
            k += 1
            visited[i] = 1
            dfs(neighbor,i,visited)
        else:
            continue

m = max(node)
nn = node.index(m)
#nn = [node[i] for i in range(N) if node[i] == m][0]
visited[nn] = 1
ans[nn] = max(c)
if N == 2:
    print(100)
    print(' '.join([str(i) for i in range(N)]))
    exit()
dfs(neigh,nn,visited)

ans2 = ' '.join([str(ans[i]) for i in range(N)])


print(sum(c)-max(c))
print(ans2)


### FIXED CODE ###

import sys
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
N = int(input())


node = [0 for i in range(N)]
neigh = [[] for j in range(N)]
ans = [0 for i in range(N)]
visited = [0 for i in range(N)]
k = 1

for i in range(N-1):
    ai,bi = map(int,input().split())
    node[ai-1] += 1
    node[bi-1] += 1
    neigh[ai-1].append(bi-1)
    neigh[bi-1].append(ai-1)
c = list(map(int,input().split()))
c.sort(reverse=True)
flag = False
def dfs(neighbor,start):
    global flag
    global k
    if sum(visited) == N:
        return 0

    for i in neighbor[start]:
        
        if visited[i] == 0:
            ans[i] = c[k]
            k += 1
            visited[i] = 1
            try:
                dfs(neighbor,i)
            except RuntimeError:
                flag = True
                return 0




m = max(node)
nn = node.index(m)
#nn = [node[i] for i in range(N) if node[i] == m][0]
visited[nn] = 1
ans[nn] = max(c)

dfs(neigh,nn)
"""
if flag:
    print(100)
    print(' '.join([str(i) for i in range(N)]))
    exit()
"""
ans2 = ' '.join([str(ans[i]) for i in range(N)])


print(sum(c)-max(c))
print(ans2)
#D問題
import math
def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

N, K = map(int, input().split())
red = N - K
for i in range(K):
    if i+1 ==1:
        ans = (red+1)
        print(ans)
    else:
        if i + 1 < K:
            divide_line = combinations_count(K-1, i)
            case =combinations_count(red+1,i+1) * divide_line
            ans = case%(10**9+7)
            print(ans)
        else:
            ans = combinations_count(red+1,K)%(10**9 + 7)
            print(ans)
    

### FIXED CODE ###

#D問題
import math
def combinations_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

N, K = map(int, input().split())
red = N - K
for i in range(1,K+1):
        if N-K+1 < i:
            print(0)
        else:
            divide_line = combinations_count(red+1, i)
            case =combinations_count(K-1,i-1) * divide_line
            ans = case%(10**9+7)
            print(ans)
n,x = map(int,input().split())

A = [1]
P = [1]
for i in range(n):
	A.append(A[i]*2+3)
	P.append(P[i]*2+1)
print(A,P)

def func(n,x):
	elif x == 1:
		return 0 if n != 0 else 1
	elif x <= 1+A[n-1]:
		return func(n-1,x-1)
	elif x == 2+A[n-1]:
		return P[n-1]+1
	elif x <= 2+2*A[n-1]:
		return P[n-1]+1+func(n-1,x-2-A[n-1])
	else:
		return 2*P[n-1]+1

print(func(n,x))

### FIXED CODE ###

n,x = map(int,input().split())

A = [1]
P = [1]
for i in range(n):
	A.append(A[i]*2+3)
	P.append(P[i]*2+1)
# print(A,P)

def func(n,x):
	if x == 1:
		return 0 if n != 0 else 1
	elif x <= 1+A[n-1]:
		return func(n-1,x-1)
	elif x == 2+A[n-1]:
		return P[n-1]+1
	elif x <= 2+2*A[n-1]:
		return P[n-1]+1+func(n-1,x-2-A[n-1])
	else:
		return 2*P[n-1]+1

print(func(n,x))
n = int(input())
s = input()
s = list(s)

count = 0
white_count = 0
white_count2 = 0

for i in range(n):
    if s[i] == ".":
        white = i
        break

while True:
    try:
        if s[white + count] == ".":
            count += 1
        else:
            break
    except:
        count -= 1
        break

for i in range(n):
    if s[i] == ".":
        white_count += 1

if count > white:
    n = n -white - white_count
    for i in range(n):
        if s[i + white + white_count] == ".":
            white_count2 += 1
    result = white + white_count2
else:
    result = white_count

print(result)


### FIXED CODE ###

n = int(input())
s = input()

count_black = 0
count_white = 0
a = n + 1
cnt_white = [0] * a
cnt_black = [0] * a
result = []

for i in range(n):
    if s[i] == ".":
        count_white += 1

cnt_white[0] = count_white

for i in range(n):
    if s[i] == "#":
        count_black += 1
    else:
        count_white -= 1
    cnt_white[i+1] = count_white
    cnt_black[i+1] = count_black

for i in range(n+1):
    result.append(cnt_black[i] + cnt_white[i])

ans = min(result)

print(ans)
n = int(input())
b = m.bit_length() - 1
ans = int('0b1'+'0'*m, 2)
print(ans)

### FIXED CODE ###

n = int(input())
b = n.bit_length() - 1
ans = int('0b1'+'0'*b, 2)
print(ans)
int main() {
    int a, b;
    cin >> a >> b;
    int c = a * b;
    if (c % 2 == 0) cout << "Even" << endl;
    else cout << "Odd" << endl;
}

### FIXED CODE ###

x, y = map(int, input().split())
if x * y % 2:
  print('Odd')
else:
  print('Even')