Harryxun/stf_run huggingface dataset:
N,K=map(int,input().split())
class SegTree:
    """
    init(init_val, ide_ele): 配列init_valで初期化 O(N)
    update(k, x): k番目の値をxに更新 O(logN)
    query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
    """
    def __init__(self, init_val, segfunc, ide_ele):
        """
        init_val: 配列の初期値
        segfunc: 区間にしたい操作
        ide_ele: 単位元
        n: 要素数
        num: n以上の最小の2のべき乗
        tree: セグメント木(1-index)
        """
        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):
        """
        k番目の値をxに更新
        k: index(0-index)
        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したものを得る
        l: index(0-index)
        r: index(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
ide_ele = 0
def segfunc(x,y):
    return max(x,y)
seg=SegTree([0]*(N+1),segfunc,ide_ele)
for i in range(N):
    a=int(input())
    seg.update(a,seg.query(max(0,a-K),min(N,a+K+1))+1)
print(seg.query(0,N+2))


### FIXED CODE ###

N,K=map(int,input().split())
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):
        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):
        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
ide_ele = 0
b=[int(input()) for _ in range(N)]
c=max(b)
def segfunc(x,y):
    return max(x,y)
seg=SegTree([0]*(c+6),segfunc,ide_ele)
for i in range(N):
    a=b[i]
    seg.update(a,seg.query(max(0,a-K),min(c+2,a+K+1))+1)
print(seg.query(0,c+3))
A,B,C=map(int,input().split())
if (A=B=C):
  print(No)
  else:
    if (A=B):
      print (Yes)
    if (A=C):
      print (Yes)
    if (B=C):
      print (Yes)
    else:
      print (No)

### FIXED CODE ###

A,B,C=map(int,input().split())
if (A==B==C):
  print ('No')
elif (A != B and A != C and B != C):
  print ('No')
else:
  print ('Yes')
isReversed = False
s = input()
q = int(input())
for i in range(q):
  t = list(input().split())
  if t[0] =='1':
    isReversed = not bool(isReversed)
  else:
    if (t[1] =='1' and isReversed == False) or (t[1] =='2' and isReversed == True) :
      s = t[2] +s
    else:
      s = s + t[2]
                                              
      
if isReversed:
  s = s[::-1]
      
print(s)

### FIXED CODE ###

a,b,c=input()
if a==b and b==c:
  print("No")
else:
  print("Yes")
import sys


input = list()
N, D = sys.stdin

for item in sys.stdin:
    input.append(item)

count = 0
for item in input:
    if 1 <= N and N <= 2*10**5:
        if D <= 0 and D <= 2*10**5:
            if abs(item[0]) <= 2*10**5 and abs(item[1]) <= 2*10**5:            
                if D >= (int(item[0])**2 + item(item[1])**2)**1/2:
                    count += 1
print(count)
    

### FIXED CODE ###

import sys


input_array = list()
N, D = map(int, input().split())
if 1 <= N and N <= 2*10**5:
    for _ in range(N):
        input_array.append(map(int, input().split()))

count = 0
for x0, x1 in input_array:
    if 0 <= D and D <= 2*10**5:
        if abs(x0) <= 2*10**5 and abs(x1) <= 2*10**5:            
            if D >= (int(x0)**2 + int(x1)**2)**(1/2):
                count += 1
print(count)
<?php

function pc_permute($items, $perms = array( )) {
    if (empty($items)) {
        $return = array($perms);
    } else {
        $return = array();
        for ($i =  0; $i < count($items); $i++) {
            $newitems = $items;
            $newperms = $perms;
            list($foo) = array_splice($newitems, $i, 1);
            array_unshift($newperms, $foo);
            $return = array_merge($return, pc_permute($newitems, $newperms));
        }
    }
    return $return;
}

$N = intval(trim(fgets(STDIN)));
$P = explode(" ",fgets(STDIN));
$Q = explode(" ",fgets(STDIN));

$a = range(1,$N);
$permutated = pc_permute($a);
sort($permutated);

$p_index = -1;
$q_index = -1;

for ($i=0; $i < count($permutated); $i++){
  if ($permutated[$i] == $P){
    $p_index = $i;
  }
  if ($permutated[$i] == $Q){
    $q_index = $i;
  }
}

$ans = abs($p_index - $q_index);
printf("%d\n",$ans);


### FIXED CODE ###

import itertools

def main():
    N = int(input())
    
    P = list(map(int, input().split()))
    Q = list(map(int, input().split()))
    
    combi = list(itertools.permutations(range(1, N+1)))
    
    pi = 0
    qi = 0
    for i in range(len(combi)):
        if list(combi[i]) == P:
            pi = i + 1
        if list(combi[i]) == Q:
            qi = i + 1
            
            
    print(abs(qi - pi))
    
main()
# coding: utf-8
# Your code here!

import sys
readline = sys.stdin.readline
read = sys.stdin.read

n,*p = map(int,read().split())
N = n*n

dist = [0]*N

for a in range(n):
    for b in range(n):
        dist[a*n+b] = min(a,n-1-a,b,n-1-b)

#print(dist)


#ans = [0]*N
ans = 0
iru = [1]*N

move = [-n,-1,1,n]
for pi in p:
    pi -= 1

    ans += dist[pi]
    iru[pi] = 0

    q = [pi]
    #更新
    
    while q:
        #print(q)
        v = q.pop()
        for i in range(4):
            if i==2 and v%n==n-1: continue
            if i==1 and v%n==0: continue
            if i==0 and v < w: continue
            if i==3 and v+w >= N: continue
            nv = v+move[i]
            if dist[nv] > dist[v] + iru[v]:
                q.append(nv)
                dist[nv] = dist[v] + iru[v]
        
                    
    #print(dist)        

print(ans)
if n==3: print(1)








### FIXED CODE ###

# coding: utf-8
# Your code here!

import sys
readline = sys.stdin.readline
read = sys.stdin.read

n,*p = map(int,read().split())
N = n*n

dist = [0]*N

for a in range(n):
    for b in range(n):
        dist[a*n+b] = min(a,n-1-a,b,n-1-b)

#print(dist)


#ans = [0]*N
ans = 0
iru = [1]*N

for pi in p:
    pi -= 1

    ans += dist[pi]
    iru[pi] = 0

    q = [pi]
    #更新
    
    while q:
        #print(q)
        v = q.pop()
        for i in [-n,-1,1,n]:
            if i==1 and v%n==n-1: continue
            if i==-1 and v%n==0: continue
            nv = v+i
            if 0 <= nv < N and dist[nv] > dist[v] + iru[v]:
                q.append(nv)
                dist[nv] = dist[v] + iru[v]
        
                    
    #print(dist)        

print(ans)
S, T = input().split()
if S == T[:len(S)-1]:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

S = input()
T = input()
if S == T[:len(S)]:
    print("Yes")
else:
    print("No")
x=0
N=int(input("整数を入力:"))

while(1==1):
    Nn=str(N/10)
    a=Nn.split(".")
    x+=int(a[1])
    N=int(a[0])
    if N==0:
        break
if x%9==0:
    print('Yes')
else:
    print('No')


### FIXED CODE ###

N=int(input())
if N%9==0:
  print('Yes')
else:
  print('No')
n=int(input())
print("Hello World" if n==1 else a+b)

### FIXED CODE ###

n=int(input())

print("Hello World" if n==1 else int(input())+int(input()))
import math
[x,y]=list(map(int,input().split()))
if ((x%3)+(y%3))%3!=0:
	print(0)
else:
	dansu=int((x+y)/3)
	r=y-dansu
	# d=1
	# rr=1
	# nr=1
	# for i in range(1,dansu+1):
		# d=d*(i%(10**9+7))
	# for i in range(1,r+1):
		# rr=rr*(i%(10**9+7))
	# for i in range(1,dansu-r+1):
		# nr=nr*(i%(10**9+7))
	
	# kotae=int(d/(rr*nr))
	kotae=math.factorial(dansu)/(math.factorial(dansu-r)*math.factorial(r))
	kotae=kotae%(10**9+7)
	
	print(kotae)

### FIXED CODE ###

[x,y]=list(map(int,input().split()))
if ((x%3)+(y%3))%3!=0:
	print(0)
else:
	n=int((x+y)/3)
	r=y-n
	if r<0 or r>n:
		print(0)
	else:
		if r>n-r:
			r=n-r
		mod=1000000007
		kaijo=[1]
		for i in range(1,n+1):
			kaijo.append(kaijo[-1]*i%mod) #これで、kaijo[i]=i!となる。
		gyakugen=[pow(kaijo[n-r],mod-2,mod)]
		for i in reversed(range(1,n-r+1)):
			gyakugen.append(gyakugen[-1]*i%mod) #これで、gyakugen[i]=n-r-iの逆元となる
		kotae=kaijo[n]*gyakugen[0]*gyakugen[n-2*r]%mod

		print(kotae)
N, M = map(int, input().split())
inf = float("inf")
dp = [[inf]*10 for _ in [0]*10]
for i in range(N):dp[i][i] = 0
d = [list(map(int, input().split())) for i in range(10)]
m = [list(map(int, input().split())) for i in range(N)]
ans = 0
 
for i in range(10):
    for j in range(10):
        dp[i][j] = d[i][j]
for k in range(10):
    for i in range(10):
        for j in range(10):
            dp[i][j] = min(dp[i][j],dp[i][k]+dp[k][j])
c=0
for i in range(N):
    for j in range(M):
        if m[i][j] != 1 and m[i][j] != -1 :
            c+=dp[m[i][j]][1]
print(c)

### FIXED CODE ###

N, M = map(int, input().split())
inf = float("inf")
dp = [[inf]*100 for _ in [0]*100]
for i in range(10):dp[i][i] = 0
d = [list(map(int, input().split())) for i in range(10)]
m = [list(map(int, input().split())) for i in range(N)]
ans = 0
 
for i in range(10):
    for j in range(10):
        dp[i][j] = d[i][j]
for k in range(10):
    for i in range(10):
        for j in range(10):
            dp[i][j] = min(dp[i][j],dp[i][k]+dp[k][j])
c=0
for i in range(N):
    for j in range(M):
        if m[i][j] != 1 :
            if m[i][j] != -1 :
                c+=dp[m[i][j]][1]
print(c)
def gcd_core(a, b):
    if b == 0:
        return a
    else:
        return gcd_core(b, a % b)


def gcd(arr):
    g = gcd_core(arr[0], arr[1])
    for i in range(2, len(arr)):
        g = gcd_core(g, arr[i])
    return g



n = int(input())
b1 = []

for i in range(n):
    b1.append(list(map(int,input().split())))

b2 = b1.copy()

b1.sort(key=lambda x:(x[0],x[1]))
b2.sort(key=lambda x:(x[1],x[0]))
# print(b1)
# print(b2)

l1_x = {}
l1_y = {}

bef_x = b1[0][0]
bef_y = b1[0][1]
for i in range(1,n):
    diff_x = b1[i][0]-bef_x
    diff_y = b1[i][1]-bef_y
    bef_x = b1[i][0]
    bef_y = b1[i][1]

    if not diff_x in l1_x:
        l1_x[diff_x] = 1
    else:
        l1_x[diff_x]+=1

    if not diff_y in l1_y:
        l1_y[diff_y] = 1
    else:
        l1_y[diff_y]+=1

x_step = max(l1_x,key = l1_x.get)
y_step = max(l1_y,key = l1_y.get)


cost1 = 1
bef_x = b1[0][0]
bef_y = b1[0][1]
for i in range(1,n):
    diff_x = b1[i][0]-bef_x
    diff_y = b1[i][1]-bef_y
    bef_x = b1[i][0]
    bef_y = b1[i][1]

    if diff_x != x_step or diff_y != y_step:
        cost1 += 1


#*****************************************************
l1_x = {}
l1_y = {}

bef_x = b2[0][0]
bef_y = b2[0][1]
for i in range(1, n):
    diff_x = b2[i][0] - bef_x
    diff_y = b2[i][1] - bef_y
    bef_x = b2[i][0]
    bef_y = b2[i][1]

    if not diff_x in l1_x:
        l1_x[diff_x] = 1
    else:
        l1_x[diff_x] += 1

    if not diff_y in l1_y:
        l1_y[diff_y] = 1
    else:
        l1_y[diff_y] += 1

x_step = max(l1_x, key = l1_x.get)
y_step = max(l1_y, key = l1_y.get)

cost2 = 1
bef_x = b2[0][0]
bef_y = b2[0][1]
for i in range(1, n):
    diff_x = b2[i][0] - bef_x
    diff_y = b2[i][1] - bef_y
    bef_x = b2[i][0]
    bef_y = b2[i][1]

    if diff_x != x_step or diff_y != y_step:
        cost2 += 1

print(min(cost1,cost2))












### FIXED CODE ###

n = int(input())
if n == 1:
    print(1)
else:
    buf = []
    for i in range(n):
        x,y = map(int,input().split())
        buf.append([x,y])
    
    buf.sort()
    
    ans = 1e9
    for i in range(n):
        for j in range(i+1,n):
            p,q = buf[j][0]-buf[i][0],buf[j][1]-buf[i][1]
    
            ind = 0
            used = set()
            tcost = 0
            befx = 0
            befy = 0
            flag = False
            while True:
                befx,befy = buf[ind][0],buf[ind][1]
                tcost += 1
                for l in range(n):
                    if l not in used:
                        tx,ty = buf[l][0],buf[l][1]
                        if tx-befx == p and ty-befy == q:
                            befx = tx
                            befy = ty
                            used.add(l)
                while True:
                    ind += 1
                    if ind == n:
                        flag = True
                        break
                    if ind in used:
                        continue
                    else:
                        break
                if flag:
                    break
            if ans > tcost:
                # print(used)
                # print(p,q,tcost)
                ans = tcost
    
    print(ans)
N = int(input())

S = str()

import math

K = [26, 702, 18278, 475254, 12356630, 321272406, 8353082582, 217180147158, 5646683826134, 146813779479510]

if K.count(N) > 0:
	for i in range (0, K.index(N)+1):
		S=S+'z'
	print(S)
	exit()

import bisect
P = bisect.bisect_right(K, N)
Mel = N- K[P-1]

for i in range (0, P):
	K = Mel//(26**(P-i))
	Mel = Mel-K*(26**(P-i))
	S=S+chr(97+K)

S=S+chr(96+Mel)

print(S)

### FIXED CODE ###

N = int(input())
Alphabet = str('abcdefghijklmnopqrstuvwxyz')
import bisect

List = [0, 26, 702, 18278, 475254, 12356630, 321272406, 8353082582, 217180147158, 5646683826134, 146813779479510, 3817158266467286, 99246114928149462, 2580398988131886038, 67090373691429037014, 1744349715977154962390, 45353092615406029022166, 1179180408000556754576342, 30658690608014475618984918]
V = []

if List.count(N) == 1:
	for i in range (0, List.index(N)):
		V.append('z')
	print(*V, sep = '')
	exit()

k = 26
A = [0]
for i in range (2, 20):
	A.append(k)
	k = k+26**i
    
S = []

B = bisect.bisect_right(A, N)

N = N-A[B-1]-1
for i in range (0, B):
	S.append(Alphabet[N%26])
	N = N//26
    
S = reversed(S)
print(*S, sep = '')
import bisect
N, Q = map(int, input().split())
A = [int(a) for a in input().split()]

def chk(x, l, m, r):
    if x >= A[-2]:
        return 1
    rr = m % 2
    xl = x - m//2 - rr
    xr = x + m//2
    
    ll = bisect.bisect_left(A, xl)
    rr = bisect.bisect_left(A, xr+1)-1
    # print(x, l, m, r, ll, rr, N)
    if rr - ll + 1 < N - rr - 2:
        if m == (m+r)//2:
            print(1/0)
        return chk(x, m, (m+r)//2, r)
    elif rr - ll + 1 > N - 1 - rr:
        if l == (l+m)//2:
            print(1/0)
        return chk(x, l, (l+m)//2, m)
    else:
        return N - rr - 1
    
    
Y = [0] * (N+1)
for i in range(1, N+1):
    Y[i] = Y[i-1] + A[-i]

Z = [0] * ((N+3)//2)
for i in range((N+1)//2):
    if ((1+N)%2)+2*i<N:
        Z[i+1] = Z[i] + A[((1+N)%2)+2*i]

# print(Y)
# print(Z)
for q in range(Q):
    x = int(input())
    t = chk(x, 0, A[-1]//2, A[-1])
    # print(t)
    print(Y[t]+Z[(N+1)//2-t])


    



### FIXED CODE ###

import sys
input = sys.stdin.readline
def calc(x):
    l, r = 0, (N+1)//2
    while r - l > 1:
        m = (l+r) // 2
        if A[m] + A[2*m] >= 2 * x:
            l = m
        else:
            r = m
    return l
    
N, Q = map(int, input().split())
A = [int(a) for a in input().split()][::-1]
B = [A[0]] + [0] * (N-1)
for i in range(1, N):
    B[i] = B[i-1] + A[i]
C = [A[0]] + [0] * (N-1)
for i in range(2, N, 2):
    C[i] = C[i-2] + A[i]
C[-1] += C[-2]
for _ in range(Q):
    x = int(input())
    c = calc(x)
    print(B[c] + (C[-1] - C[2*c] if c*2<=N else 0))
import sys
if n == 0:
  print(x)
  sys.exit()
x, n = map(int, input().split())
lst = list(map(int, input().split()))
for i in range(250):
  if x - i not in lst:
    print(x + i)
    sys.exit()
  if x + i not in lst:
    print(x + i)
    sys.exit()

### FIXED CODE ###

import sys
x, n = map(int, input().split())
if n == 0:
  print(x)
  sys.exit()
lst = list(map(int, input().split()))
for i in range(250):
  if x - i not in lst:
    print(x - i)
    sys.exit()
  if x + i not in lst:
    print(x + i)
    sys.exit()
print(["NO","YES"][int(input())%4==0])

### FIXED CODE ###

from sys import stderr, setrecursionlimit
from functools import reduce
from operator import add
setrecursionlimit(2147483647)
def f(n=1):
    if n == 1:
        return [int(i) for i in input().split()]
    res = []
    for i in range(n):
        res.append([int(j) for j in input().split()])
    return res
def debug(*x, sep=" ", end="\n"):
    for item in x:
        stderr.write(str(item))
        stderr.write(sep)
    stderr.write(end)

rgb = int("".join(input().split()))
print("NO" if rgb%4 else "YES")
import numpy as np
from copy import deepcopy
temp=list(map(int, input().split()))
R=temp[0]
C=temp[1]

color=np.zeros((R,C)).astype(int)

for i in range(R):
  temp=input()
  a=np.zeros(C).astype(int)
  for j in range(C):
      if temp[j]=='#':
        a[j]=1
      else:
        a[j]=0
  color[i]=a
  
def Adj(u):
  adj=[]
  for v in [(u[0]-1,u[1]),(u[0]+1,u[1]),(u[0],u[1]-1),(u[0],u[1]+1)]:
      if v[0]>=0 and v[0]<R and v[1]>=0 and v[1]<C:
        adj.append(v)
  return adj  

def BFS(s,c,d):
  ma=0
  Q=[s]
  while Q !=[]:
    u=Q[0]
    del Q[0]
    if d[x,y]>ma:
      ma=d[x,y]
    for v in Adj(u):  
      if c[v[0],v[1]]==0:
        c[v[0],v[1]]=1
        d[v[0],v[1]]=d[u[0],u[1]]+1
        Q.append(v)
  return ma
        
def main():
  for sx in range(R):
    for sy in range(C):
      if color[sx,sy]==0:
        d=np.zeros((R,C)).astype(int)
        c=deepcopy(color)
        ma=BFS((sx,sy),c,d)
  print(ma)
  
main()


### FIXED CODE ###

import numpy as np
from copy import deepcopy
temp=list(map(int, input().split()))
R=temp[0]
C=temp[1]

color=np.zeros((R,C)).astype(int)

for i in range(R):
  temp=input()
  a=np.zeros(C).astype(int)
  for j in range(C):
      if temp[j]=='#':
        a[j]=1
      else:
        a[j]=0
  color[i]=a
  
def Adj(u):
  adj=[]
  for v in [(u[0]-1,u[1]),(u[0]+1,u[1]),(u[0],u[1]-1),(u[0],u[1]+1)]:
      if v[0]>=0 and v[0]<R and v[1]>=0 and v[1]<C:
        adj.append(v)
  return adj  

def BFS(s,c,d):
  ma=0
  Q=[s]
  while Q !=[]:
    u=Q[0]
    del Q[0]
    if d[u[0],u[1]]>ma:
      ma=d[u[0],u[1]]
    for v in Adj(u):  
      if c[v[0],v[1]]==0:
        c[v[0],v[1]]=1
        d[v[0],v[1]]=d[u[0],u[1]]+1
        Q.append(v)
  return ma
        
def main():
  ma=0
  for sx in range(R):
    for sy in range(C):
      if color[sx,sy]==0:
        d=np.zeros((R,C)).astype(int)
        c=deepcopy(color)
        c[sx,sy]=1
        ma=max(BFS((sx,sy),c,d),ma)
  print(ma)

main()
def CountingSort(A, k):
    C = [0] * k
    B = C[:]
    for a in A:
        C[a] += 1
    for i in range(1, len(C)):
        C[i] += C[i - 1]
    for i in range(len(A) - 1, -1, -1):
        B[C[A[i]]] = A[i]
        C[A[i]] -= 1
    return B




if __name__ == '__main__':
    N = int(input())
    A = [int(i) for i in input().strip().split()]
    sorted_A = CountingSort(A, int(3E10))
    print(' '.join([str(a) for a in sorted_A[1:len(A) + 1]]))

### FIXED CODE ###

def CountingSort(A, k):
    C = [0] * k
    B = C[:]
    for a in A:
        C[a] += 1
    for i in range(1, len(C)):
        C[i] += C[i - 1]
    for i in range(len(A) - 1, -1, -1):
        B[C[A[i]]] = A[i]
        C[A[i]] -= 1
    return B



if __name__ == '__main__':
    N = int(input())
    A = [int(i) for i in input().strip().split()]
    sorted_A = CountingSort(A, int(3E6))
    print(' '.join([str(a) for a in sorted_A[1:len(A) + 1]]))
N=int(input())
if N<10:
  A=N
elif N<100:
  A=9
elif N<1000:
  A=9+N-99
elif N<10000:
  A=9+900
elif N<100000:
  A=9+900+N-9999
else
  A=9+900+90000  
print(A)

### FIXED CODE ###

N=int(input())
if N<10:
  A=N
elif N<100:
  A=9
elif N<1000:
  A=9+N-99
elif N<10000:
  A=9+900
elif N<100000:
  A=9+900+N-9999
else:
  A=9+900+90000  
print(A)
S=input()
if S=='hi' orS=='hihi' or S=='hihihi' or S=='hihihihi' or S=='hihihihihi':
  print("Yes")
else:
  print("No")


### FIXED CODE ###

S=input()
if S=='hi' or S=='hihi' or S=='hihihi' or S=='hihihihi' or S=='hihihihihi':
  print("Yes")
else:
  print("No")
N = int(input())
for i in range(1, 10):
  if N / i == int(N / i):
    if N / i < 10:
      print("Yes")
      return
print("No")

### FIXED CODE ###

import sys
N = int(input())
for i in range(1, 10):
  if N / i == int(N / i):
    if N / i < 10:
      print("Yes")
      sys.exit()
print("No")
n=input()
v=list(map(int, input().split()))
c=list(map(int, input().split()))
for i in range(n)
t[i]=v[i]-c[i]
a=0
for i in range(n)
if t[i]>0 :
a+=t[i]
print(a)

### FIXED CODE ###

n=input()
v=list(map(int, input().split()))
c=list(map(int, input().split()))
t=[i-j if i-j>0 else 0 for i,j in zip(v,c)]
print(sum(t))
n, m = map(int, input().split())
a = list(map(lambda x:int(x) // 2, input().split()))

def gcd(a, b):
	while b:
		a, b = b, a % b
	return a

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

temp = lcm(a[0], a[1])
if (temp // a[0]) % 2 == 0 or (temp // a[1]) % 2 == 0:
    print(0)
    exit()

for y in a[2:]:
    temp = lcm(temp, y)
    if (temp // y) % 2 == 0 or temp > m:
        print(0)
        exit()

ans = m // temp
print(ans - ans // 2)

### FIXED CODE ###

n, m = map(int, input().split())
a = list(map(lambda x:int(x) // 2, input().split()))

a = sorted(list(set(a)))

def gcd(a, b):
	while b:
		a, b = b, a % b
	return a

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

if len(a) == 1:
    ans = m // a[0]
    print(ans - ans // 2)
    exit()

temp = lcm(a[0], a[1])
if (temp // a[0]) % 2 == 0 or (temp // a[1]) % 2 == 0:
    print(0)
    exit()

for y in a[2:]:
    temp = lcm(temp, y)
    if (temp // y) % 2 == 0 or temp > m:
        print(0)
        exit()

ans = m // temp
print(ans - ans // 2)
s = list(input())
k = [s[0], s[1], s[2], s[3]]
l = [s[5], s[6]]
a = ''.join(int(_) for _ in k)
b = ''.join(int(_) for _ in l)

if a > 2019:
    print('TBD')

elif a == 2018 and b > 4:
    print('TBD')

else:
    print('Heisei')

### FIXED CODE ###

s = input()
s1 = [s[0], s[1], s[2], s[3]]
s2 = [s[5], s[6]]

t1 = int(''.join(s1))
t2 = int(''.join(s2))

if t1 > 2019:
    print('TBD')

elif t1 == 2019 and t2 > 4:
    print('TBD')

else:
    print('Heisei')
stack =[]
for item in raw_input().split():
    stack.append(item)


def Cal(sym,n1,n2):
    n1 = int(n1)
    n2 = int(n2)
    if sym == '+':
        ans = n1 + n2
    elif sym == '-':
        ans = n1 - n2
    else:
        ans = n1 * n2
        
    return ans

sym_stack = []
ans_stack = []

while len(stack)>0:
    m = stack.pop()
    if not m.isdigit():
        sym_stack.append(m)
    else:
        n2 = m
        n1 = stack.pop()
        sym = sym_stack.pop()
        ans = Cal(sym,n1,n2)
        ans_stack.append(ans)


n2 = ans_stack.pop()
n1 = ans_stack.pop()
sym = sym_stack.pop()
Ans = Cal(sym,n1,n2)

print Ans

### FIXED CODE ###

def Cal(sym,n1,n2):
    n1 = int(n1)
    n2 = int(n2)
    if sym == '+':
        ans = n1 + n2
    elif sym == '-':
        ans = n1 - n2
    else:
        ans = n1 * n2
        
    return ans

stack = []

for item in raw_input().split():
    if item.isdigit():
        stack.append(item)
    else:
        n2 = stack.pop()
        n1 = stack.pop()
        sym = item
        ans = Cal(sym,n1,n2)
        stack.append(ans)

Ans = stack.pop()

print Ans
#include <iostream>
#include <vector>

using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    if (a*b %2 == 0){
        printf("Even");
    } else{
        printf("Odd");
    }

    return 0;
}

### FIXED CODE ###

n,m= map(int, input().split())
print("Even" if (n*m)%2 == 0 else "Odd")