CodeEff/ECCO huggingface dataset:
# Original solution
N, K = list(map(int, input().split()))
dK = 2*K

MeetDemand =[[0 for c in range(dK+1)] for r in range(dK)]
for i in range(N):
    x, y, c =input().split()
    x = int(x) % dK
    y = (int(y)+K if c=="W" else int(y)) % dK
    
    if 0 <= x < K and 0 <= y < K:
        MeetDemand[0][0] += 1
        MeetDemand[x+1][y+1] += 2
        MeetDemand[0][y+1] -= 1
        MeetDemand[x+1][0] -= 1
        MeetDemand[0][y+K+1] += 1
        MeetDemand[x+1][y+K+1] -= 2
    elif 0 <= x < K:
        MeetDemand[0][y-K+1] += 1
        MeetDemand[x+1][y-K+1] -= 2
        MeetDemand[x+1][0] += 1
        MeetDemand[0][y+1] -= 1
        MeetDemand[x+1][y+1] += 2
    elif 0 <= y < K:
        MeetDemand[x-K+1][0] += 1
        MeetDemand[x-K+1][y+1] -= 2
        MeetDemand[0][y+1] += 1
        MeetDemand[0][y+K+1] -= 1
        MeetDemand[x-K+1][y+K+1] += 2
    else:
        MeetDemand[0][0] += 1
        MeetDemand[0][y-K+1] -= 1
        MeetDemand[x-K+1][0] -= 1
        MeetDemand[x-K+1][y-K+1] += 2
        MeetDemand[0][y+1] += 1
        MeetDemand[x-K+1][y+1] -= 2

for x in range(K):
    for y in range(1, dK):
        MeetDemand[x][y] += MeetDemand[x][y-1]
for y in range(dK):
    for x in range(1, K):
        MeetDemand[x][y] += MeetDemand[x-1][y]

Ans = max(MeetDemand[0][:dK])
for i in range(1, K):
    Ans = max(Ans, max(MeetDemand[i][:dK]))
print(Ans)

# Optimized solution
N, K = list(map(int, input().split()))
dK = 2*K

MeetDemand =[[0 for y in range(dK+1)] for x in range(K+1)]
for i in range(N):
    x, y, c =input().split()
    x = int(x) % dK
    y = (int(y)+K if c=="W" else int(y)) % dK
    if K <= x:
        if 0 <= y < K:
            x -= K
            y += K
        else:
            x %= K
            y %= K
    if 0 <= y < K:
        MeetDemand[0][0] += 1
        MeetDemand[x+1][y+1] += 2
        MeetDemand[0][y+1] -= 1
        MeetDemand[x+1][0] -= 1
        MeetDemand[0][y+K+1] += 1
        MeetDemand[x+1][y+K+1] -= 2
    else:
        MeetDemand[0][y-K+1] += 1
        MeetDemand[x+1][y-K+1] -= 2
        MeetDemand[x+1][0] += 1
        MeetDemand[0][y+1] -= 1
        MeetDemand[x+1][y+1] += 2

for x in range(K):
    for y in range(1, dK):
        MeetDemand[x][y] += MeetDemand[x][y-1]
for y in range(dK):
    for x in range(1, K):
        MeetDemand[x][y] += MeetDemand[x-1][y]

Ans = max(MeetDemand[0][:dK])
for i in range(1, K):
    Ans = max(Ans, max(MeetDemand[i][:dK]))
print(Ans)
# Original solution
def get(i1, j1, i2, j2):
  if i1 > i2 or j1 > j2 or i1 < 0 or j1 < 0 or i2 < 0 or j2 < 0:
    return 0
  elif i1 > 0 and j1 > 0:
    return l[i2][j2] - l[i1-1][j2] - l[i2][j1-1] + l[i1-1][j1-1]
  elif i1 <= 0 < j1:
    return l[i2][j2] - l[i2][j1-1]
  elif j1 <= 0 < i1:
    return l[i2][j2] - l[i1 - 1][j2]
  else:
    return l[i2][j2]

N, K = list(map(int, input().split()))
K2 = 2*K
R = []
l=[[0] * K2 for _ in range(K2)]

for i in range(N):
  xi, yi, ci = input().split()
  if ci == "W":
    yi = int(yi) + K
  xi, yi = int(xi), int(yi)
  l[xi%K2][yi%K2]+=1

for y in range(K2):
  for x in range(1,K2):
    l[x][y] += l[x-1][y]
for y in range(1,K2):
  for x in range(K2):
    l[x][y] += l[x][y-1]

ans = 0
for i in range(K):
  for j in range(K):
    tmp = 0
    tmp += get(0, 0, i-1, j-1)
    tmp += get(0, j+K, i-1, K2-1)
    tmp += get(i+K, j+K, K2-1, K2-1)
    tmp += get(i+K, 0, K2-1, j-1)
    tmp += get(i, j, i+K-1, j+K-1)

    ans = max(ans, tmp, N-tmp)
print(ans)


# Optimized solution
def cl(i1,j1,i2,j2):
  if i1>i2 or j1>j2 or i1<0 or j1<0 or i2<0 or j2<0:
    return 0
  v=l[i2][j2]
  if i1>0:
    v-=l[i1-1][j2]
  if j1>0:
    v-=l[i2][j1-1]
  if i1>0 and j1>0:
    v+=l[i1-1][j1-1]
  return v

N,K=list(map(int,input().split()))
K2=2*K
l=[[0]*K2 for _ in range(K2)]

for i in range(N):
  xi,yi,ci=input().split()
  xi,yi=int(xi),int(yi)
  if ci=="W":yi+=K
  l[xi%K2][yi%K2]+=1

for y in range(K2):
  for x in range(1,K2):
    l[x][y]+=l[x-1][y]
for y in range(1,K2):
  for x in range(K2):
    l[x][y]+=l[x][y-1]

ans=0
for i in range(K):
  for j in range(K):
    tmp=0
    tmp+=cl(0,0,i-1,j-1)
    tmp+=cl(0,j+K,i-1,K2-1)
    tmp+=cl(i+K,j+K,K2-1,K2-1)
    tmp+=cl(i+K,0,K2-1,j-1)
    tmp+=cl(i,j,i+K-1,j+K-1)
    ans = max(ans,tmp,N-tmp)
print(ans)
# Original solution
from collections import defaultdict

def calc(K, xyc):
    K2 = K * 2
    N = len(xyc)

    m = defaultdict(int)
    for x, y, c in xyc:
        y += c * K
        x1, y1 = x % K2, y % K2
        x2, y2 = x1 + K, y1 + K
        m[x1, y1] += 1
        m[x2, y2] += 1
        m[x2, y1] -= 1
        m[x1, y2] -= 1
        x1, y1 = (x + K) % K2, (y + K) % K2
        x2, y2 = x1 + K, y1 + K
        m[x1, y1] += 1
        m[x2, y2] += 1
        m[x2, y1] -= 1
        m[x1, y2] -= 1

    ms = [[0] * (K2 + 1) for i in range(K2 + 1)]
    for y in range(0, K2):
        ms0 = ms[y]
        ms1 = ms[y - 1]
        for x in range(0, K2):
            ms0[x] = m[x, y] + ms0[x-1] + ms1[x] - ms1[x-1]
    
    rmax = 0
    for y in range(K, K2):
        for x in range(K, K2):
            rcount = ms[y][x]
            rmax = max(rmax, rcount, N - rcount)

    return rmax

if __name__ == '__main__':
    N, K = [int(e) for e in input().split()]
    xyc = [(int(x), int(y), c == "W") for x, y, c in [input().split() for i in range(N)]]
    print((calc(K, xyc)))


# Optimized solution
def calc(K, xyc):
    K2 = K * 2
    N = len(xyc)

    p = [[0] * K2 for i in range(K2)]
    for x, y, c in xyc:
        y += c * K
        p[x % K2][y % K2] += 1
        p[(x + K) % K2][(y + K) % K2] += 1

    def isum(xs):
        r = 0
        yield r
        for x in xs:
            r += x
            yield r

    psum = [list(isum(row)) for row in p]
    pksum = [[b - a for a, b in zip(row, row[K:])] for row in psum]

    rmax = N / 2
    for y in range(K):
        rcount = sum(row[y] for row in pksum[:K])
        for x in range(K):
            rmax = max(rmax, rcount, N - rcount)
            rcount += -pksum[x][y] + pksum[x + K][y]

    return rmax

if __name__ == '__main__':
    N, K = [int(e) for e in input().split()]
    xyc = [(int(x), int(y), c == "W") for x, y, c in [input().split() for i in range(N)]]
    print((calc(K, xyc)))
# Original solution
def calc(K, xyc):
    K2 = K * 2
    N = len(xyc)

    p = [[0] * K2 for i in range(K2)]
    for x, y, c in xyc:
        y += c * K
        p[x % K2][y % K2] += 1
        p[(x + K) % K2][(y + K) % K2] += 1

    def isum(xs):
        r = 0
        yield r
        for x in xs:
            r += x
            yield r

    psum = [list(isum(row)) for row in p]
    pksum = [[b - a for a, b in zip(row, row[K:])] for row in psum]

    rmax = N / 2
    for y in range(K):
        rcount = sum(row[y] for row in pksum[:K])
        for x in range(K):
            rmax = max(rmax, rcount, N - rcount)
            rcount += -pksum[x][y] + pksum[x + K][y]

    return rmax

if __name__ == '__main__':
    N, K = [int(e) for e in input().split()]
    xyc = [(int(x), int(y), c == "W") for x, y, c in [input().split() for i in range(N)]]
    print((calc(K, xyc)))


# Optimized solution
def calc(K, xyc):
    K2 = K * 2
    N = len(xyc)

    p = [[0] * K2 for i in range(K2)]
    for x, y, c in xyc:
        y += c * K
        p[x % K2][y % K2] += 1
        p[(x + K) % K2][(y + K) % K2] += 1

    def calcsum(xs):
        r = sum(xs[:K])
        yield r
        for a, b in zip(xs[:K], xs[K:]):
            r += -a + b
            yield r

    pksum = [list(calcsum(xs)) for xs in p]

    rmax = N / 2
    for y in range(K):
        rcount = sum(row[y] for row in pksum[:K])
        for x in range(K):
            rmax = max(rmax, rcount, N - rcount)
            rcount += -pksum[x][y] + pksum[x + K][y]

    return rmax

if __name__ == '__main__':
    N, K = [int(e) for e in input().split()]
    xyc = [(int(x), int(y), c == "W") for x, y, c in [input().split() for i in range(N)]]
    print((calc(K, xyc)))
# Original solution
import functools
import operator
print(('Even' if (functools.reduce(operator.mul,list(map(int,input().split()))))%2==0 else 'Odd'))

# Optimized solution
print(('Odd' if len([1 for i in list(map(int,input().split())) if i%2!=0])==2 else 'Even'))
# Original solution
a,b=input().split();print(('EOvdedn'[eval(a+'*'+b)%2!=0::2]))

# Optimized solution
print(('EOvdedn'[eval(input().replace(' ','*'))%2!=0::2]))
# Original solution
print(('EOvdedn'[eval(input().replace(' ','*'))%2::2]))

# Optimized solution
a,b=list(map(int,input().split()));print(('EOvdedn'[a%2 and b%2::2]))
# Original solution
lis = []
lis = input().split()
answer  = 1
for lis_value in lis:
    answer *= int(lis_value)
print(("Even" if answer % 2 == 0 else "Odd"))

# Optimized solution
a,b = list(map(int,input().split()))
if a*b % 2 == 0:
    print("Even")
else:
    print("Odd")
# Original solution
a, b = list(map(int, input().split()))
print(('Odd' if a & 1 and b & 1 else 'Even'))

# Optimized solution
a, b = list(map(int, input().split()))
print(('Odd' if a*b % 2 == 1 else 'Even'))
# Original solution
import operator
import functools
number_list = list(map(int, input().split()))
product = functools.reduce(operator.mul, number_list)
if product % 2 == 0:
    print('Even')
else:
    print('Odd')

# Optimized solution
a, b = list(map(int, input().split()))
if (a * b % 2) == 0:
    print('Even')
else:
    print('Odd')
# Original solution
a,b = list(map(int, input().split()))
print(("Even" if (a * b) % 2 == 0 else "Odd"))

# Optimized solution
a,b = list(map(int, input().split()))
if (a * b) % 2 == 0:
  print("Even")
else:
  print("Odd")
# Original solution
a, b = input().split(' ')

multi_a_b = int(a) * int(b)

if multi_a_b % 2 == 0:
    print('Even')
else:
    print('Odd')

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

if (a * b) % 2 == 0:
    print('Even')
else:
    print('Odd')
# Original solution
a,b=list(map(int,input().split()))
v=a*b
print(("Even" if v%2==0 else "Odd"))


# Optimized solution
a,b=map(int,input().split())
print("Even") if a*b%2==0 else print("Odd")
# Original solution
(a, b) = list(map(int, input().split()))
if a % 2 == 1 and b % 2 == 1:
    print("Odd")
else:
    print("Even")

# Optimized solution
a, b = list(map(int, input().split()))
if a % 2 == 1 and b % 2 == 1:
    print("Odd")
else:
    print("Even")
# Original solution
a, b = list(map(int, input().split()))
if a*b % 2 == 0:
    print("Even")
else:
    print("Odd")

# Optimized solution
a, b=list(map(int, input().split()))
s="Odd" if a%2!=0 and b%2!=0 else "Even"
print(s)
# Original solution
a,b=list(map(int,input().split()))
print(('Odd'if a*b%2==1else'Even'))

# Optimized solution
a,b=list(map(int,input().split()));print((['Even','Odd'][a*b%2]))
# Original solution
a, b =list(map(int, input().split()))
product = a * b
if product % 2 == 0:
    print("Even")
else:
    print("Odd")

# Optimized solution
a, b = list(map(int, input().split()))
pro = a * b
if pro % 2 == 0:
    print("Even")
else:
    print("Odd")
# Original solution
a,b = list(map(int, input().split()))
print(("Odd" if a*b%2!=0 else "Even"))

# Optimized solution
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
    print('Even')
else:
    print('Odd')
# Original solution
# -*- codinf: utf-8 -*-

# コマンドラインの入力文字をリストに格納
# input().split() -> 入力文字を空白区切りで取得　※inputは文字列として取得する。split()でリスト型に変換
# for num in input().split() -> 取得した入力文字を一つずつnum変数に格納
# int(num)で格納されたnum変数を数値に変換
numList = [int(num) for num in input().split()]

# 入力文字の乗算
productNumList = numList[0] * numList[1]

# 奇数／偶数の判定
if ((productNumList % 2) == 0 ):
    print("Even")
else:
    print("Odd")


# Optimized solution
#2019/10/10
a, b = list(map(int, open(0).read().split()))
print(("Odd" if (a*b)%2!=0 else "Even"))
# Original solution
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
INF = 10**18

a,b=rl()
print('Odd' if a*b%2==1 else 'Even')


# Optimized solution
ri = lambda: int(input())
rl = lambda: list(map(int,input().split()))
rr = lambda N: [ri() for _ in range(N)]
YN = lambda b: print('YES') if b else print('NO')
yn = lambda b: print('Yes') if b else print('No')
OE = lambda x: print('Odd') if x%2 else print('Even')
INF = 10**18

a,b=rl()
#print('Odd' if a*b%2==1 else 'Even')
OE(a*b)
# Original solution
a,b = list(map(int,input().split()))
num = a * b
mod = num % 2

if mod == 0:
  print("Even")
else:
  print("Odd")

# Optimized solution
a,b = list(map(int,input().split()))
if a*b%2==0:
  print("Even")
else:
  print("Odd")
# Original solution
a,b = list(map(int,input().split()))
if a*b%2==0:
        print("Even")
else:
        print("Odd")

# Optimized solution
a,b = list(map(int,input().split()))
c = a*b
print(("Odd" if c%2==1 else "Even"))
# Original solution
# #! /bin/python

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

# print('{} {}'.format(a+b+c,s))

# 11 22 といった形で標準入力を数値で受け取る。
a,b = list(map(int,input().split()))
# if (not (1 <= a <= 10000)) or (not (1 <= b <= 10000)):
#     print('over flow argument!')
#     exit()


if 1 <= a <= 10000:
    if 1 <= b <= 10000:
        pass
else:
    exit()


def checkEvenOdd(a,b):
    mult = a * b

    if mult % 2:
        print('Odd')
    else:
        print('Even')

checkEvenOdd(a,b)

# Optimized solution
# #! /bin/python

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

# print('{} {}'.format(a+b+c,s))

# 11 22 といった形で標準入力を数値で受け取る。
a,b = list(map(int,input().split()))
# if (not (1 <= a <= 10000)) or (not (1 <= b <= 10000)):
#     print('over flow argument!')
#     exit()


def checkEvenOdd(a,b):
    mult = a * b

    if mult % 2:
        print('Odd')
    else:
        print('Even')

checkEvenOdd(a,b)
# Original solution
a,b = list(map(int,input().split()))

if(a * b) % 2 == 0 :
    print("Even")
else:
    print("Odd")

# Optimized solution
x,y = map(int,input().split())
print('Even') if((x*y%2) == 0) else print('Odd')
# Original solution
a, b = list(map(int, input().split()))
print(('EOvdedn'[a*b%2::2]))

# Optimized solution
print(('EOvdedn'[eval(input().replace(' ', '*'))%2::2]))
# Original solution
num1, num2 = list(map(int,input().split()))

if num1 * num2 % 2 ==0:
  	print('Even')
else:
	print('Odd')

# Optimized solution
a, b = tuple(int(num) for num in input().split())
ab = a * b

if ab % 2:
  print('Odd')
else:
  print('Even')
# Original solution
a, b = list(map(int, input().split()))
print(("Even" if a*b % 2 == 0 else "Odd"))

# Optimized solution
a, b = list(map(int, input().split()))
if a*b%2 == 0:
  print("Even")
else:
  print("Odd")
# Original solution
d, g  = list(map(int, input().split()))
if d * g  % 2 == 1:
    print('Odd')
else:
    print('Even')

# Optimized solution
d, g  = list(map(int, input().split()))
if d % 2 == 1 and g % 2 == 1:
    print('Odd')
else:
    print('Even')
# Original solution
a, b = list(map(int, input().split()))
if a % 2 != 0 and b % 2 != 0:
    print('Odd')
else:
    print('Even')

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

m = a * b

if m % 2 != 0:
    print('Odd')
else:
    print('Even')
# Original solution
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
	print('Even')
else:
	print('Odd')

# Optimized solution
# -*- coding: utf-8 -*-

def main():
    a, b = list(map(int, input().split()))
    print((['Even', 'Odd'] [a * b % 2]))

if __name__ == '__main__':
    main()
# Original solution
a, b = list(map(int, input().split()))
print(("Even" if a*b % 2 == 0 else "Odd"))

# Optimized solution
a,b = list(map(int,input().split()))
num = a * b
if num % 2 == 0:
    print("Even")
else:
    print("Odd")
# Original solution
a , b = list(map(int,input().split()))

if (a * b)%2 ==0:
  print("Even")
else:
  print("Odd")

# Optimized solution
# ABC 086
A,B= list(map(int,input().split()))
if (A* B)%2==0:
    ans ='Even'
else:
    ans='Odd'
print(ans)
# Original solution
print(("Even" if eval(input().replace(" ","*"))%2==0 else "Odd"))

# Optimized solution
a,b=list(map(int,input().split()))
if a*b%2==0:
  print("Even")
else:
  print("Odd")
# Original solution
a,b = list(map(int,input().split()))
if (a * b) % 2 == 1:
    print("Odd")
else:
    print("Even")


# Optimized solution
a,b = list(map(int,input().split()))
if a*b % 2 == 1:
   print("Odd")
else:
   print("Even")
# Original solution
a,b=list(map(int,input().split()))
if a*b%2:
  print('Odd')
else:
  print('Even')

# Optimized solution
a,b=list(map(int,input().split()))
if a*b%2==0:
  print('Even')
else:
  print('Odd')
# Original solution
a,b = input().split()
 
if (int(a)*int(b))%2==0:
    print("Even")
else:
    print("Odd")

# Optimized solution
a,b = list(map(int,input().split()))
print(("Even" if a*b%2==0 else "Odd"))
# Original solution
a,b = list(map(int,input().split()))
print(("Even" if a*b%2==0 else "Odd"))

# Optimized solution
a,b=list(map(int,input().split()))
print(("Odd" if a*b%2 else "Even"))
# Original solution
a, b = list(map(int, input().split()))

if a%2 == 0 or b%2 == 0:
    print("Even")
else:
    print("Odd")

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

if (a*b)%2 == 0:
    print("Even")
else:
    print("Odd")
# Original solution
x, y = list(map(int, input().split()))
if x * y % 2:
  print('Odd')
else:
  print('Even')

# Optimized solution

a, b = list(map(int, input().split()))
if (a*b)%2 == 0:
  print("Even")
else:
  print("Odd")
# Original solution
a,b=list(map(int,input().split()))

def evenodd(a,b):
  if a*b%2==1:
    return "Odd"
  else:
    return"Even"
    
print((evenodd(a,b)))

# Optimized solution
a,b=list(map(int,input().split()))
if a*b%2==1:
  print('Odd')
else:
  print('Even')
# Original solution
a,b = list(map(int, input().split()))
c = a * b
if c % 2 == 0:
    print("Even")
else:
    print("Odd")

# Optimized solution
a, b = list(map(int, input().split()))
if (a*b % 2) == 0:
    print("Even")
else:
    print("Odd")
# Original solution
# -*- coding: utf-8 -*-
# スペース区切りの整数の入力
a, b = list(map(int, input().split()))
c = a * b
if c % 2 == 0:
  print("Even")
else:
  print("Odd")

# Optimized solution
i = list(map(int, input().split()))
j = i[0] * i[1]
if j % 2 == 0:
  print("Even")
else:
  print("Odd")
# Original solution
a,b = list(map(int,input().split()))
if (a*b) % 2 == 0:
  print('Even')
else:
  print('Odd')

# Optimized solution
a,b = list(map(int,input().split()))
if a*b%2==0:
  print('Even')
else:
  print('Odd')
# Original solution
[a, b] = list(map(int, input().split()))
if a * b % 2 == 0:
  print("Even")
else:
  print("Odd")

# Optimized solution
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
  print("Even")
else:
  print("Odd")
# Original solution
a, b = list(map(int, input().split()))

print(("Even" if a * b % 2 == 0 else "Odd"))


# Optimized solution
a, b = list(map(int, input().split(' ')))
print(("Even" if a % 2 == 0 or b % 2 == 0 else "Odd"))
# Original solution
a, b = list(map(int, input().split()))

if a * b % 2 == 0:
  print("Even")
else:
  print("Odd")
  

# Optimized solution
a, b = list(map(int, input().split()))
print(('Even' if a*b % 2 == 0 else 'Odd'))
# Original solution
for _ in range(10**7*5):None
a,b=list(map(int,input().split()))
print(('EOvdedn'[a*b%2::2]))

# Optimized solution
print(('EOvdedn'[eval(input().replace(*' *'))%2::2]))
# Original solution
a, b = list(map(int, input().split()))
if (a*b) % 2:
  print("Odd")
else:
  print("Even")

# Optimized solution
x = input().split()
a =int(x[0])
b =int(x[1])
if (a*b) % 2:
  print("Odd")
else:
  print("Even")
# Original solution
x = input().split()
a =int(x[0])
b =int(x[1])
if (a*b) % 2:
  print("Odd")
else:
  print("Even")

# Optimized solution
x = input().split()
y = int(x[0])*int(x[1])
if y % 2:
  print("Odd")
else:
  print("Even")
# Original solution
x = input().split()
y = int(x[0])*int(x[1])
if y%2 == 1:
  print("Odd")
else:
  print("Even")

# Optimized solution
a,b = list(map(int,input().split()))
if a*b%2:
  print("Odd")
else:
  print("Even")
# Original solution
a,b = list(map(int,input().split()))
if (a*b)%2 != 0:
    print("Odd")
else:
    print("Even")


# Optimized solution
a, b = list(map(int, input().split()))
num = a*b
if num % 2==0:
    print("Even")
else:
    print("Odd")
# Original solution
a, b = list(map(int, input().split()))
if (a*b)%2:
    print("Odd")
else:
    print("Even")


# Optimized solution
a, b = list(map(int, input().split()))
if (a*b)%2 == 1:
    print("Odd")
else:
    print("Even")
# Original solution
a, b = list(map(int, input().split()))		# 5 7

if (a*b)%2 == 0:
	print('Even')
else:
	print('Odd')



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

if a%2==0 or b%2==0:
  print("Even")
else:
  print("Odd")
# Original solution
a, b = list(map(int, input().split()))
if a*b%2 == 1:
    print("Odd")
else:
    print("Even")

# Optimized solution
a, b = list(map(int, input().split()))
print(('Odd'if a&b&1 else 'Even'))
# Original solution
a, b = list(map(int, input().split()))
a = int(a)
b = int(b)

i = a*b

if i%2 == 0:
  print('Even')
else:
  print('Odd')
    

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

i = a * b

if i % 2 ==0:
  print('Even')
else:
  print('Odd')
# Original solution
# -*- coding: utf-8 -*-

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

if a * b % 2 == 0:
  print('Even')
else:
  print('Odd')

# Optimized solution
# -*- coding: utf-8 -*-

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

out = ['Even', 'Odd']
print((out[a * b % 2]))
# Original solution
string = input().split(' ')
first = string[0]
second = string[1]
if int(first)*int(second)%2 == 0:
    print("Even")
else:
    print("Odd")

# Optimized solution
s = input().split(" ")

a = int(s[0])
b = int(s[1])
if (a*b)%2 == 0:
 print("Even")
else:
 print("Odd")
# Original solution
def ketanowa(p):
    ans=0
    p=str(p)
    for i in p:
        ans+=int(i)
    return ans

def main():
    temp=input().split(" ")
    n=int(temp[0])
    a=int(temp[1])
    if n*a%2==0:
        print("Even")
    else:
        print("Odd")

    

if __name__ == '__main__':
    main()


# Optimized solution
a,b=input().split()
c=int(a)*int(b)
if c%2==0:
  print("Even")
else:
  print("Odd")
# Original solution
a,b=list(map(int,input().split()))

if a*b % 2 ==0:
	print("Even")
else:
	print("Odd")
	

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

if (a*b)%2==0:
	print("Even")
else:
	print("Odd")
# Original solution
a,b=list(map(int,input().split()))
if a%2==0 or b%2==0:
  print("Even")
else:
  print("Odd")

# Optimized solution
a,b = list(map(int,input().split()))
if a%2==1 and b%2==1:
  print("Odd")
else:
  print("Even")
# Original solution
a = list(map(int, input().split()))

if(a[0] * a[1] % 2 == 0):
  print('Even')
else:
  print('Odd')

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

if(a * b % 2 == 0):
  print('Even')
else:
  print('Odd')
# Original solution
a,b = list(map(int,input().split()))
ans = 0
if a*b%2==0:
  print('Even')
else:
  print('Odd')


# Optimized solution
R= list(map(int,input().split()))
if R[0] * R[1] % 2 == 0:
    print('Even')
else:
    print('Odd')
# Original solution
a,b = [int(s) for s in input().split()]
print((('Even', 'Odd')[(a*b)%2]))


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

if ((a*b) % 2):
    print('Odd')
else:
    print('Even')
# Original solution
a, b = list(map(int, input().split()))

if a % 2 == 1 and b % 2 == 1:
	print("Odd")
else:
	print("Even")

# Optimized solution
def resolve():
    a, b = list(map(int, input().split()))

    if a % 2 == 1 and b % 2 == 1:
        print("Odd")
    else:
        print("Even")

resolve()
# Original solution
a, b = list(map(int, input().split()))
sum = a*b
if sum % 2 == 0:
  print("Even")
  
else:
  print("Odd")


# Optimized solution
a, b = list(map(int,input().split()))
if (a*b) % 2 == 0:
  print("Even")
else:
  print("Odd")
# Original solution
a, b = list(map(int, input().split()))
if (a * b % 2) == 0:
    print('Even')
else:
    print('Odd')

# Optimized solution
a, b = list(map(int, input().split()))
if (a * b) % 2 == 0:
    print('Even')
else:
    print('Odd')
# Original solution
a, b = list(map(int, input().split()))
if a * b % 2 == 0:
    print('Even')
else:
    print('Odd')

# Optimized solution
a, b = list(map(int, input().split()))
print(('Odd' if a * b % 2 == 1 else 'Even'))
# Original solution
a,b = list(map(int, input().split()))
if a*b % 2 == 0:
	print("Even")
else:
	print("Odd")

# Optimized solution
a,b = list(map(int, input().split()))
ans = a * b
if ans % 2 == 0:
	print("Even")
else:
	print("Odd")