Harryxun/stf_run huggingface dataset:
from sympy import sieve


def main():
    number = int(input())
    isPrime = False
    while not isPrime:
        isPrime = (number in sieve) == True
        if not isPrime:
            number += 1
    print(number)


if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    X = int(input())
    i = 2
    while i ** 2 <= X:
        if X % i == 0:
            X += 1
            i = 2
        else:
            i += 1
    print(X)

if __name__ == '__main__':
    main()
n=int(input())
 s= []
for _ in range(n):
    s.append(input())
count=0
for i in range(n):
    for j in range(i):
        if s[i]==s[j]:
            count=count
        else:
            count=count+1
print(count)

### FIXED CODE ###

n = int(input())
s = [input() for i in range(n)]
print(len(set(s)))
a、b=map(int, input(),split())
x =a+b
y =a-b
z =a*b
print(max(x,y,z))

### FIXED CODE ###

A, B = map(int, input().split())
print(max(A + B, A - B, A * B))
def solve(j,sum):
    if j==n-1:
        ans[sum] = 1
        if sum+A[j] <= 2000:
            ans[sum+A[j]] = 1
    solve(j+1,sum)
    if sum+A[j] <= 2000:
        solve(j+1,sum+A[j])

n=int(input())
A=[]*n
A=list(input().split())
for i in range(n):
    A[i]=int(A[i])
ans=[0]*2001    
solve(0,0)   

m=int(input())
B=list(input().split())
for i in range(m):
    B[i]=int(B[i])
for i in range(m):
    if ans[B[i]]==1:
        print("yes")
    else:
        print("no")


### FIXED CODE ###

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

T = [[0]*2001 for i in range(n)]

T[0][0] = 1
T[0][A[0]] = 1
for i in range(1,n):
    for j in range(2001):
        T[i][j] = T[i-1][j]
        if (j - A[i] >=0) and (T[i-1][j-A[i]] == 1):
            T[i][j] = 1
    
for i in range(m):
    if T[n-1][B[i]] == 1: print("yes")
    else: print("no")
from math import sqrt
from sys import stdin
def pm(n):
    l = list(range(3,n+1)[0::2])
    p = 3
    i = 0
    p = l[i]
    m = sqrt(n)+1
    while p <= m:
        l = l[:i+1] + [n for n in l[i+1:] if n%p != 0]
        i += 1
        p = l[i]
    return len(l) + 1

for n in stdin:
    print pm(int(n))

### FIXED CODE ###

from math import sqrt,floor
from sys import stdin

def cntPrime(n):
    mx = sqrt(n)
    if n % 2 == 0:
      l = [0, 1] + [1, 0] * (int(n/2) - 1)
    else:
      l = [0, 1] + [1, 0] * (int(n/2) - 1) + [1]
    c = 3
    while c < mx:
        for k in range(c*2, n+1, c):
            l[k-1] = 0
        c = l[(c+1):].index(1) + c +2
        while c % 2 == 0:
            c = l[(c+1):].index(1) + c +2
    return l
t = cntPrime(1000000)
for n in stdin:
    n = int(n)
    print(sum(t[:n]))
s = input()
r = []
for i in range(len(s)):
    if s[i] == "0":
        r.append("0")
    elif s[i] == "1":
        r.append("1")
    elif s[0] == "B":
        continue
    else:
        del r[-1]



print("".join(r))


### FIXED CODE ###

s = input()
r = []
for i in range(len(s)):
    if s[i] == "0":
        r.append("0")
    elif s[i] == "1":
        r.append("1")
    elif s[i] == "B" and len(r) != 0:
        del r[-1]

    else:
        continue
print("".join(r))
a,b = map(intinput().split())
#L = list(map(int,input().split()))
if a==b:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

a,b = map(int,input().split())
#L = list(map(int,input().split()))
if a==b:
    print("Yes")
else:
    print("No")
from sys import exit

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

if max(c) < 0:
    res = max(c)
else:
    res = 0

for i in range(n):
    score = []
    s = 0
    pos = i
    visited = [False] * n
    loop = 0
    while True:
        if visited[pos]:
            break

        visited[pos] = True
        s += c[p[pos]-1]
        score.append(s)
        pos = p[pos] - 1
        loop += 1

    if len(score) == 0:
        print(-809984039214)
        exit()

    if k < loop:
        res = max(res, max(score[:k]))
    elif score[-1] <= 0:
        res = max(res, max(score))
    else:
        res = max(res, score[-1] * (k // loop) + max(score[:k%loop]), score[-1] * (k // loop - 1) + max(score))

print(res)

### FIXED CODE ###

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

if max(c) < 0:
    res = max(c)
else:
    res = 0

for i in range(n):
    score = []
    s = 0
    pos = i
    visited = [False] * n
    loop = 0
    while True:
        if visited[pos]:
            break

        visited[pos] = True
        s += c[p[pos]-1]
        score.append(s)
        pos = p[pos] - 1
        loop += 1

    if k < loop:
        res = max(res, max(score[:k]))
    elif score[-1] <= 0:
        res = max(res, max(score))
    elif k % loop == 0:
        res = max(res, score[-1] * (k // loop), score[-1] * (k // loop - 1) + max(score))
    else:
        res = max(res, score[-1] * (k // loop) + max(score[:k%loop]), score[-1] * (k // loop - 1) + max(score))

print(res)
import math
from functools import reduce

def gcd(*numbers):
    return reduce(math.gcd, numbers)

n, x = map(int,input().split())
li = list(map(int,input().split()))
d = [abs(x-li[0])]

for i in range(n-1):
    d.append(abs(li[i]-li[i+1]))

print(gcd(*d))

### FIXED CODE ###

import fractions
from functools import reduce
 
def gcd(*numbers):
    return reduce(fractions.gcd, numbers)

n, x = map(int,input().split())
li = list(map(int,input().split()))
d = [abs(x-li[0])]
 
for i in range(n-1):
    d.append(abs(li[i]-li[i+1]))

print(gcd(*d))
H,W,A,B=map(int,input().split())
a=[ [-1 for _ in range(W)] for _ in range(H) ]

L=0
for i in range(H):
  R=min(L+A,W)
  for j in range(L,R):
    a[i][j]=0
  for j in range(R,W):
    a[i][j]=1
  if L+A>W:
    p =L+A
    for j in range(0,p):
      a[i][j]=1
    L=p
  else:
    for j in range(0,L):
      a[i][j]=1
    L =L+A

for j in range(W):
  cnt=0
  for i in range(H):
    cnt += a[i][j]
  if min(cnt,H-cnt)>B:
    ans="No"
    print(ans)
    exit()
else:
  for gyou in a:
    st = list( map(str,gyou) )
    print("".join(st))

### FIXED CODE ###

H,W,A,B = map(int,input().split())

for i in range(B):
  print("0" * A+ "1" * (W-A))
for i in range(B,H):
  print("1" * A+ "0" * (W-A))
b, c = map(int, input().split())
a = list(map(int, input().split()))
d = sum(a)
new_a = list(reversed(sorted(a)))
e = 0
f = 0
g = 4*c
while new_a[e] >= d/g:
    e = e+1
    f = f+1
if f >= c:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

n, m = map(int, input().split())
ai = list(map(int, input().split()))
required = sum(ai) / (4 * m)
count = 0
for a in sorted(ai, reverse=True):
    if a >= required:
        count += 1
    else:
        break
print("YNeos"[count < m::2])
v,n=[int(k) for k in input().split()]
li=[]
for i in range(n):
  li.append([int(k) for k in input().split()])
  
dp=[[0 for i in range(v+1)] for j in range(n+1)]
for a in range(1,n+1):
  for b in range(1,v+1):
    if(li[a-1][0]<=b):
      dp[a][b]=max(li[a-1][1]+dp[a-1][b-li[a-1][0]],dp[a-1][b])
    else:
      dp[a][b]=dp[a-1][b]
print(dp[n][v])      
      
  

### FIXED CODE ###

n,v=[int(k) for k in input().split()]
li=[]
for i in range(n):
  li.append([int(k) for k in input().split()])
  
dp=[[0 for i in range(v+1)] for j in range(n+1)]
for a in range(1,n+1):
  for b in range(1,v+1):
    if(li[a-1][0]<=b):
      dp[a][b]=max(li[a-1][1]+dp[a-1][b-li[a-1][0]],dp[a-1][b])
    else:
      dp[a][b]=dp[a-1][b]
print(dp[n][v])
#coding: utf-8
N, M = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(N)]
money = 0
AB = sorted(AB, key=lambda x: x[0])
if M <= AB[0][1]:
  money += AB[0][0] * AB[0][1]
else:
  i = 0
  while M >= 0:
    money += AB[i][0] * AB[i][1]
    M -= AB[i][1]
    if M <= 0:
      money += AB[i][0] * M
    i += 1
print(money)

### FIXED CODE ###

#coding: utf-8
import numpy as np
N, M = map(int, input().split())
AB = np.array([list(map(int, input().split())) for _ in range(N)])
money = 0
col_num = 0
AB = AB[np.argsort(AB[:, col_num])]
if M <= AB[np.argmin(AB[:, 0]), 1]:
    money += AB[0, 0] * M
else:
    i = 0
    while M > 0:
        money += AB[i, 0] * AB[i, 1]
        M -= AB[i, 1]
        if M <= 0:
          money += AB[i, 0] * M
        i += 1
print(money)
a,b,c=map(int,input().split())
if a+b=c or a+c=b or b+c=a:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

a,b,c=map(int,input().split())
if a+b==c or a+c==b or b+c==a:
    print("Yes")
else:
    print("No")
import math
n,k=map(int,input().split())
temp=0
for i in range(1,n+1):
  temp+=2**(-math.ceil(log(k/i,2)))
  
print(temp/n)  

### FIXED CODE ###

import math
n,k=map(int,input().split())
temp=0
for i in range(1,n+1):
  if k<i:temp+=1
  else:temp+=2**(-math.ceil(math.log(k/i,2)))
  
print(temp/n)
#import matplotlib.pyplot as plt
#import networkx as nx

n, m = map(int, input().split())
D = [list(map(int, input().split())) for i in range(m)]

G = [[0, 0, []] for i in range(n+1)]


#print(G.nodes())
for i in range(m) :
    G[D[i][0]][2].append([D[i][1], D[i][2]])
    G[D[i][1]][2].append([D[i][0], -D[i][2]])

global no
no = 0

def d(a):
    G[a][1] = 1
    A = []
    #print(len(G[a][2]))
    #print(G[a][2][0][0])
    for j in range(len(G[a][2])) :
        i = G[a][2][j][0]
        #print(set(list(nx.all_neighbors(G, a))))
        #print("{} {}".format(a,i))
        if G[i][1] == 0 :
            A.append(i)
            G[i][0] = G[a][0] + G[a][2][j][1]
            G[i][1] = 1
        else :
            #print("{} {} {}".format(G[i][0],G[a][0],G[a][2][j][1]))
            if G[i][0] != G[a][0] + G[a][2][j][1] :
                #print("A")
                global no
                no = 1
                #print("{} {}".format("no",no))
    for i in A :
        d(i)

for i in range(1,n+1):
    if G[i][1] == 0 :
        d(i)
        
if no == 1 :
    print("No")
else :
    print("Yes")
        


### FIXED CODE ###

n, m = map(int, input().split())
D = [list(map(int, input().split())) for i in range(m)]

A = [0] * (n+1)

M = [[] for i in range(n+1)]

for i in range(m):
    M[D[i][0]].append([D[i][1], D[i][2]])
    M[D[i][1]].append([D[i][0], -D[i][2]])

V = [0] * (n+1)


# print(M)

for ii in range(1, n+1):
    if V[ii] == 0 and len(M[ii]) > 0:

        Q = [[ii, 0]]
        st = 0
        while st < len(Q):
            # print(A,V,Q)
            node = Q[st][0]
            dist = Q[st][1]
            if V[node] == 0 and len(M[node]) > 0:
                V[node] = 1
                A[node] += dist
                for i in M[node]:
                    if V[i[0]] == 0:
                        Q.append([i[0], A[node] + i[1]])
            st += 1

# print(A)

def d():
    for i in range(m):
        if A[D[i][1]] - A[D[i][0]] != D[i][2]:
            return "No"
    return "Yes"

print(d())
from math import gcd
N, O = map(int, input().split())
X = list(map(int, input().split()))
X.append(O)
X.sort()
diff = [x-y for x, y in zip(X[1:], X[:-1])]
# print(diff)
for i in range(N-1):
    diff[i+1] = gcd(diff[i], diff[i+1])
print(diff[N-1])

### FIXED CODE ###

from fractions import gcd
N, O = map(int, input().split())
X = list(map(int, input().split()))
X.append(O)
X.sort()
diff = [x-y for x, y in zip(X[1:], X[:-1])]
# print(diff)
for i in range(N-1):
    diff[i+1] = gcd(diff[i], diff[i+1])
print(diff[N-1])
from functools import lru_cache

N, M = map(int, input().split(' '))

@lru_cache(maxsize=4096)
def fib(n):
    if n < 2:
        return n
    else:
        return fib(n - 1) + fib(n -2)

safe_area = []
a_p = int(input())
sum = fib(a_p)
for i in range(M-1):
    a = int(input())
    diff = a - a_p
    if diff == 1:
        print('0')
        exit()
    sum *= fib(diff-1)
    a_p = a

sum *= fib(N - a_p)

print(sum % 1000000007)


### FIXED CODE ###

N, M = map(int, input().split(' '))

MOD = 1000000007

def fib(n):
    a, b = 0, 1
    for i in range(0, n):
        a, b = b, a + b
    return a

broken_step = []
p_a = -1
for i in range(M):
    a = int(input())
    if (a - p_a == 1):
        print("0")
        exit()
    else:
        p_a = a
    broken_step.append(a-1)

count_0 = 0
count_1 = 1
next_broken = 0
pre_is_broken = False
for i in range(N):
    if (next_broken >= len(broken_step) or i != broken_step[next_broken]):
        if (pre_is_broken):
            count_0 = 0
            pre_is_broken = False
        else:
            count_0, count_1 = count_1, count_0 + count_1
            count_0 %= MOD
            count_1 %= MOD
    else:
        next_broken+=1
        count_0 = 0
        pre_is_broken = True

print(count_1)
a,b,c,d,e,d=map(int,input().split())
ans=[100*a,0]
for i in range(f//(100*a)+1):
  for j in range((f-100*a*i)//(100*b)+1):
    for k in range(f//c+1):
      for l in range((f-c*k)//d+1):
        if 100*a*i+100*b*j+c*k+d*l>f:
          break
        elif c*k+d*l>(a*i+b*j)*e:
          break
        else:
          if (c*k+d*l)/(100*a*i+100*b*j+c*k+d*l)>ans[1]/ans[0]:
            ans=[100*a*i+100*b*j+c*k+d*l,c*k+d*l]
print(ans[0],ans[1])

### FIXED CODE ###

a,b,c,d,e,f=map(int,input().split())
ans=[100*min(a,b),0]
for i in range(31):
  for j in range(31):
    if i==0 and j==0:
      break
    l1=f-(100*a*i+100*b*j)
    l2=(a*i+b*j)*e
    l=min(l1,l2)
    cc,dc=0,0
    for k in range(l//c+1):
      tc=k
      td=(l-c*tc)//d
      if l-(c*tc+d*td)<l-(c*cc+d*dc):
        cc,dc=tc,td
    wa=100*a*i+100*b*j
    sa=c*cc+d*dc
    tmp=[wa+sa,sa]
    if wa+sa>f or sa>e*(a*i+b*j):
      break
    if tmp[1]/tmp[0]>ans[1]/ans[0]:
      ans=tmp
print(ans[0],ans[1])
X,Y= map(int, input().split())
if (Y/2-X>=0 and 2*X-Y/2>=0) and ( not (Y/2-X<=0 and 2*X-Y/2<=0)):
    print ("Yes")
else:
    print("No") 
        

### FIXED CODE ###

a,b,c,d,e = map(int, input().split())
li=[a,b,c,d,e ]
print(li.index(0)+1)
n = int(input())
h_list = list(map(int,input().split()))
ans_list =[]
ans = 0
t = 0
while t <= n-2:
  if h_list[t] >= h_list[t+1]:
    ans += 1
    if t == n-2:
      ans_list.append(ans)
  else:
    ans_list.append(ans)
    ans = 0
  t += 1
print(max(ans_list))

### FIXED CODE ###

n = int(input())
h_list = list(map(int,input().split()))
max = 0
ans = 0
for t in range(0,n-1):
  if h_list[t] >= h_list[t+1]:
    ans += 1
    if ans >= max:
      max = ans
  else:
    ans = 0
print(max)
X,t=input().split

print(max(X-t,0))

### FIXED CODE ###

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

print(max(x-t,0))
import numpy as np
h, w = map(int, input().split())
S = [list(input()) for _ in range(h)]

def calc(s):
    res = []
    for v in s:
        v.append('-')
        tmp = []
        nc = ''
        nn = 0
        for c in v:
            if nc == '':
                nc = c
                nn += 1
                continue
            if nc == c:
                nn += 1
                continue
            else:
                if nc == '#':
                    tmp = tmp + [0 for _ in range(nn)]
                else:
                    tmp = tmp + [nn for _ in range(nn)]
                nc = c
                nn = 1
        res.append(tmp)
    return res

def calc2(s):
    res = []
    for j in range(w):
        v = ['-']
        tmp = []
        nc = ''
        nn = 0
        for i in range(h+1):
            if i == h:
                c = '-'
            else:
                c = s[i][j]
            if nc == '':
                nc = c
                nn += 1
                continue
            if nc == c:
                nn += 1
                continue
            else:
                if nc == '#':
                    tmp = tmp + [0 for _ in range(nn)]
                else:
                    tmp = tmp + [nn for _ in range(nn)]
                nc = c
                nn = 1
        res.append(tmp)
    return res

tate = np.asarray(calc2(S)).T
yoko = np.asarray(calc(S))
print((tate + yoko).max() - 1)


### FIXED CODE ###

h, w = map(int, input().split())
S = [input() for _ in range(h)]

def calc(s):
    res = []
    for v in s:
        v = v + '-'
        tmp = []
        nc = v[0]
        nn = 0
        for c in v:
            if nc == c:
                nn += 1
                continue
            else:
                if nc == '#':
                    tmp.extend([0 for _ in range(nn)])
                else:
                    tmp.extend( [nn for _ in range(nn)])
                nc = c
                nn = 1
        res.append(tmp)
    return res

def calc2(s):
    res = []
    for j in range(w):
        tmp = []
        nc = s[0][j]
        nn = 0
        for i in range(h):
            c = s[i][j]
            if nc == c:
                nn += 1
                continue
            else:
                if nc == '#':
                    tmp.extend([0 for _ in range(nn)])
                else:
                    tmp.extend( [nn for _ in range(nn)])
                nc = c
                nn = 1
        if nc == '#':
            tmp.extend([0 for _ in range(nn)])
        else:
            tmp.extend( [nn for _ in range(nn)])
        res.append(tmp)
    return res

tate = calc2(S)
yoko = calc(S)

print(max([tate[j][i] + yoko[i][j] for i in range(h) for j in range(w) if tate[j][i] * yoko[i][j] != 0]) - 1)
n = int(input())
s = input()

arr = []
R = len(list(filter(lambda x:x == 'R', s)))
G = len(list(filter(lambda x:x == 'G', s)))
B = len(list(filter(lambda x:x == 'B', s)))
tot = R*G*B

for i in range(n):
  for j in range(i+1, n):
    k = 2*j-i
    if k > n:
      continue
    if (s[i] != s[j]) & (s[i] != s[k]) & (s[j] != s[k]):
      tot -= 1

print(tot)

### FIXED CODE ###

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

arr = []
R = len(list(filter(lambda x:x == 'R', s)))
G = len(list(filter(lambda x:x == 'G', s)))
B = len(list(filter(lambda x:x == 'B', s)))
tot = R*G*B

for i in range(n):
  for j in range(i+1, n):
    k = 2*j-i
    if k >= n:
      continue
    if (s[i] != s[j]) and (s[i] != s[k]) and (s[j] != s[k]):
      tot -= 1

print(tot)
n = int(input())
R = list(map(int, input().split()))
c, i = 0, 1
for r in R:
  if r==i: i+=1
  else: c+=1
print(c if c<N else '-1')

### FIXED CODE ###

from collections import deque
n = int(input())
r = deque(map(int, input().split()))
i=0
while True:
    if max(len(r),i)==i:
        break
    if r[i]!=i+1:
        r.popleft()
    else:
        i+=1
print('-1' if len(r)==0 else n-len(r))
X, Y = map(int, input().split())

for a in range(101):
  b = x - a
  if 2 * a + 4 * b == Y:
    print('Yes')
    exit()
print('No')

### FIXED CODE ###

X, Y = map(int, input().split())

for a in range(101):
  b = X - a
  if 2 * a + 4 * b == Y and b >= 0:
    print('Yes')
    exit()
print('No')
import sys

S = list(map(int, sys.stdin.readline()))
len_S = len(S)
ans = 0
for i in range(2 ** (len_S - 1)):
  sum_ = S[len_S - 1]
  cursor = len_S - 1
  power = 0
  while cursor > 0:
    cursor -= 1 
    if i % 2 == 1:
      power += 1
    else:
      power = 0
    sum_ += S[cursor] * (10 ** power)
    i >>= 1
  ans += sum_
      
print(ans)
    

### FIXED CODE ###

import sys

S = list(map(int, sys.stdin.readline().strip()))
len_S = len(S)
ans = 0
for i in range(2 ** (len_S - 1)):
  sum_ = S[len_S - 1]
  cursor = len_S - 1
  power = 0
  while cursor > 0:
    cursor -= 1 
    if i % 2 == 1:
      power += 1
    else:
      power = 0
    sum_ += S[cursor] * (10 ** power)
    i >>= 1
  ans += sum_
print(ans)
a = list(map(int,input().split()))
b = a[0] - a[2]
if b <= 0:
  ans = a[1] + b
  print('0 {}'.format(ans))
else:
  print('{} {}'.format(b, a[1]))


### FIXED CODE ###

s, t = input().split(" ")
print(t+s)
text = input()

text1 = text.strip(text[0])
text2 = text1.strip(text1[0])

if len(text) == 4 and len(text1) == 2 and len(text2) == 0:
  print("Yes")
else:
  print("No")


### FIXED CODE ###

text = input()

text1 = text.replace(text[0], "")
try:
	text2 = text1.replace(text1[0], "")
except:
	text2 = "e"

if len(text) == 4 and len(text1) == 2 and len(text2) == 0:
  print("Yes")
else:
  print("No")
X, A, B = map(int, input().split())
if B - A <= 0:
  print("delicious")
elif:
  0 < B - A and B - A <= X:
  print("safe")
else:
  print("dangerous")

### FIXED CODE ###

X, A, B = map(int, input().split())
if B - A <= 0:
  print("delicious")
elif 0 < B - A <= X:
  print("safe")
else:
  print("dangerous")
n = int(input())
line1 = list(map(int,input().split()))
line2 = list(map(int,input().split()))
sum1 = sum(line1)
sum2 = sum(line2)
count1 = line1[0]
count2 = 0
box = []
for i in range(1,n-1):
  count1 += line1[i]
  count2 += line2[i-1]
  totalgap = count2 +sum1 - count1
  box.append(totalgap)
print(sum1 + sum2 - min(box))

### FIXED CODE ###

n = int(input())
line1 = list(map(int,input().split()))
line2 = list(map(int,input().split()))
sum1 = sum(line1)
sum2 = sum(line2)
count1 = 0
count2 = 0
box = []
for i in range(0,n):
  count1 += line1[i]
  count2 += line2[i]
  totalgap = count2 - line2[i] +sum1 - count1
  box.append(totalgap)
print(sum1 + sum2 - min(box))
N=int(input())
A=list(map(int,input().split()))
ans=0

while True:
  for i in range(N):
    if A[i]&1==0:
      A[i]=A[i]>>1
    else:
      print(ans)
      return
  ans+=1


### FIXED CODE ###

N=int(input())
A=list(map(int,input().split()))
ans=0
flag=0

while flag==0:
  for i in range(N):
    if A[i]&1==0:
      A[i]=A[i]>>1
    else:
      print(ans)
      flag=1
      break
  ans+=1
A,B =map(int,input().split())
if (A*B)52==0:
  print("Even")
else:
  print("Odd")

### FIXED CODE ###

A,B =map(int,input().split())
if (A*B)%2==0:
  print("Even")
else:
  print("Odd")
def gcd(a,b):
  while b>=1:
    a,b=b,a%b
  return a
def lcm(a,b):
  return a*b/gcd(a,b)
N=int(input())
List_T=[int(input()) for i in range(N)]
T=1
n=1
for i in List_T:
  T=lcm(T,i)
print(int(T))

### FIXED CODE ###

def gcd(a,b):
  if a<b:
    a,b=b,a
  while b>0:
    a,b=b,a%b
  return int(a)
N=int(input())
T=1
for i in range(N):
  ti=int(input())
  T=T*ti//gcd(T,ti)
print(T)
x1=x**3
print(x1)

### FIXED CODE ###

x=int(input())
print(x**3)