Harryxun/stf_run huggingface dataset:
N, K = list(map(int,input().rstrip().split()))
ans = 0
for i in range(1,N+1):
    p = 1/N
    if j<K:
        while i<K:
            i *= 2
            p *= 0.5
    ans += p
print(ans)

### FIXED CODE ###

N, K = list(map(int,input().rstrip().split()))
ans = 0
for i in range(1,N+1):
    p = 1/N
    if i<K:
        while i<K:
            i *= 2
            p *= 0.5
    ans += p
print(ans)
#167
#c
import sys
import itertools
import numpy
n,m,x  = map(int, input().split())
zentan = itertools.product([0,1],repeat = m)
condi  = []
for i in range(n):
    ln = list(map(int, input().split()))
    condi.append(ln)
cost_min = 10**10
for i in zentan:
    cost = 0
    skills= [0]*m
    
    for k,j in enumerate(i): # zentan i 
      cost += condi[k][0]*j
      for c in range(1,m +1):
        skills[c-1]+= condi[k][c]*j
    
    if min(skills) >= x:
        cost_min = min(cost,cost_min)

if cost_min<10**10:
    print(cost_min)
else:
    print('-1')
                

### FIXED CODE ###

#167
#c
import sys
import itertools
import numpy
n,m,x  = map(int, input().split())
zentan = itertools.product([0,1],repeat = n)
condi  = []
for i in range(n):
    ln = list(map(int, input().split()))
    condi.append(ln)
min_cost = 10**10
for i in zentan:# e.g.   i = (0,0, ...) len(i ) = n
    cost = 0
    skills= [0]*m
    # cost 
    for n1, n2 in enumerate(i):# n1 = 0~n-1, n2 = i[n1]
        cost += condi[n1][0]*n2
        #skills
        for n3 in range(m): # n3 = 0~m-1
            skills[n3] += condi[n1][n3+1]*n2
    if min(skills) >= x and cost < min_cost:
        min_cost = cost
    
        

            
            
if min_cost<10**10:
    print(min_cost)
else:
    print('-1')
a = input()

if a == ABC:
  print("ARC")
else:
  print("ARC")

### FIXED CODE ###

a = input()
 
if a == "ABC":
  print("ARC")
if a == "ARC":
  print("ABC")
S=int(input())
m=S//2019
ans=0
baisu=[]
for i in range(m):
  baisu.append(2019*(i+1))
for num in baisu:
  if num in str(S):
    ans += 1
print(ans)


### FIXED CODE ###

s_inv = str(input())[::-1]
dp = [1]+[0]*2018
MOD = 0
ans = 0
num = 0
k = 1

for i in range(len(s_inv)):
  num+=int(s_inv[i])*k
  MOD = num % 2019
  dp[MOD] += 1
  k = k*10
  k %= 2019
for i in dp:
  ans += i*(i-1)/2

print(int(ans))
s = input()
t = input()

[globals().update({'s': s.translate(str.maketrans({s[i]: t[i], t[i]: s[i]}))}) for i in range(len(s))]

print("Yes" if s == t else "No")


### FIXED CODE ###

input_data = [int(i) for i in input().split(" ")]

ans = 0
for k1, v1 in enumerate(input_data):
    for k2, v2 in enumerate(input_data):
        for k3, v3 in enumerate(input_data):
            if k1 == k2 or k2 == k3 or k3 == k1:
                continue
            kou1 = int(str(v1) + str(v2))
            kou2 = v3
            if ans < kou1 + kou2:
                ans = kou1 + v3
print(ans)
w = input()
 
s = "Sunny"
c = "Cloudy"
r = "Rainy"
 
if w == s:
  print(c)
elif w == c:
  print(r)
else w == r:
  print(s)

### FIXED CODE ###

w = input()

s = "Sunny"
c = "Cloudy"
r = "Rainy"
 
if w == s:
  print(c)
elif w == c:
  print(r)
else:
  print(s)
from collections import deque
from heapq import heapify, heappush, heappop
def main():
    n, m, k = map(int, input().split())
    a = [int(x) for x in input().split()]
    b = [int(x) for x in input().split()]
    a_q = deque(a)
    b_q = deque(b)
    i = 0
    l = []
    heapify(l)
    point = 0
    cnt = 0
    aq = a_q.popleft()
    bq = b_q.popleft()
    heappush(l, aq)
    heappush(l, bq)
    if sum(a) + sum(b) <= k:
        print(len(a) + len(b))
    else:
        while point <= k:
            min_l = heappop(l)
            if point + min_l > k:
                print(cnt)
                exit()
            else:
                point += min_l
                cnt += 1
            if min_l == aq:
                if len(a_q) != 0:
                    aq = a_q.popleft()
                    heappush(l, aq)
            else:
                if len(b_q) != 0:
                    bq = b_q.popleft()
                    heappush(l, bq)
        print(cnt)

if __name__ == '__main__':
    main()


### FIXED CODE ###

def main():
    n, m, k = map(int, input().split())
    a = [int(x) for x in input().split()]
    b = [int(x) for x in input().split()]

    acum = [0] * (n + 1)
    bcum = [0] * (m + 1)
    for i in range(n):
        acum[i + 1] = acum[i] + a[i]
    for i in range(m):
        bcum[i + 1] = bcum[i] + b[i]
        
    j = m
    maxv = 0
    for i in range(n+1):
        if acum[i] > k:
            break
        while acum[i] + bcum[j] > k:
            j -= 1
        maxv = max(maxv, i + j)
    print(maxv)

if __name__ == '__main__':
    main()
n,k=map(int,input().split())
lst=[k<h int(h) for h in input().split()]
x=len(lst)
print(x)

### FIXED CODE ###

n, k = map(int, input().split())
lst = [int(i) for i in input().split()]
print(len([j for j in lst if j >= k]))
S = input()
T = input()
if T[0:-1] == S:
  print("Heisei")
else:
  print("TBD")

### FIXED CODE ###

S = input()
if int(S[5:7]) <= 4:
    print("Heisei")
else:
    print("TBD")
N, M = map(int, input().split())

A = list(map(int, input().split()))

B = []
for i in range(M):
    b, c = map(int, input().split())
    for j in range(b):
        B.append(c)

A.sort()
B.sort(reverse=True)
for i in range(M):
    if A[i] < B[i]:
        A[i] = B[i]

ans = sum(A)
print(ans)

### FIXED CODE ###

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

A = list(map(int, input().split()))

count = 0
BC = []
for i in range(M):
    b, c = map(int, input().split())
    BC.append((b, c))

A.sort()
BC.sort(reverse=True, key=lambda x: x[1])

count = 0
CArr = []
for b, c in BC:
    if count >= N:
        break
    for i in range(b):
        CArr.append(c)
        count += 1
        if count >= N:
            break

for i in range(len(CArr)):
    if A[i] < CArr[i]:
        A[i] = CArr[i]

ans = sum(A)
print(ans)
n = int(input())
A = [list(map(int, input().split())) for i in range(n)]
B = [e[:] for e in A]

for k in range(n):
    for i in range(n):
        for j in range(n):
            B[i][j] = min(B[i][k] + B[k][j], B[i][j])
ok = 1
for i in range(n):
    for j in range(n):
        if A[i][j] != B[i][j]:
            ok = 0
if not ok:
    print(-1)
    exit(0)

ans = 0
for i in range(n):
    for j in range(i+1, n):
        need = 1
        for k in range(n):
            if i == k or j == k:
                continue
            if A[i][k] + A[k][j] == A[i][j]:
                need = 0
        if need:
            ans += A[i][j]
print(ans)


### FIXED CODE ###

import sys
sys.setrecursionlimit(100000)
a, b, c, d, e, f = map(int, input().split())
def dfs(g, a, b, can, base=100):
    if not base*g <= f:
        return
    if g in can:
        return
    can[g] = 1
    dfs(g + a, a, b, can, base)
    dfs(g + b, a, b, can, base)
can1 = {}
dfs(0, a, b, can1)
can2 = {}
dfs(0, c, d, can2, 1)

ans = (0, 0, 0)
for g in can1:
    if g == 0:
        continue
    rest = f - 100*g
    result = max([0]+[h for h in can2 if h <= min(rest, e*g)])
    ans = max(ans, (result / (100.*g + result), 100*g+result, result))
print(*ans[1:])
N,D = map(int, input().split())

A = 0

for i in range(N):
  X,Y = map(int, input().split())
  
for g in range(N):
  if X**2 + Y**2 <= D**2:
    A += 1
    
print(A)

### FIXED CODE ###

X = int(input())
 
if X >= 30:
    print("Yes")
 
else:
    print("No")
n = int(input())

dic = {}
for _ in range(n):
    s = input()
    dic[s] = dic.get(s, 0) + 1

c = collections.Counter(dic)

print("\n".join(sorted([ k for k,v in c.items() if v == max(c.values()) ])))

### FIXED CODE ###

import collections
n = int(input())

c = {}
for _ in range(n):
    s = input()
    c[s] = c.get(s, 0) + 1

u = max(c.values())
print("\n".join(sorted([ k for k,v in c.items() if v == u ])))
import sys

def input():
    return sys.stdin.readline().strip()

def main():
    x, n= map(int, input().split())
    if n == 0:
        print(x)
        return
    P=[]
    P = list(map(int, input().split()))
    
    for i in range(100):
        a = x-i
        b = x+i
        if a not in P:
            print(a)
            return
        elif b not in P:
            print(b)
            return
    


main()



### FIXED CODE ###

import sys

def input():
    return sys.stdin.readline().strip()

def main():
    n = int(input())
    A = list(map(int, input().split()))
    M = max(A)
    B = [0]*(M+1)
    ans = 0
    A.sort()
    
    for i in A:
        B[i] += 1
    
    for i in A:
        if B[i] == 1:
            ans += 1
        for j in range(i, M+1, i):
            B[j] += 1
    
    print(ans)

main()
h, n = map(int, input().split())

a = [map(int, input().split()) for _ in range(n)]
print(a)
for i in a:
    h -= a
if h <= 0:
    print('Yes')
else:
    print('No')


### FIXED CODE ###

h, n = map(int, input().split())
a = [int(x) for x in input().split()]

h -= sum(a)

if h <= 0:
    print('Yes')
else:
    print('No')
from collections import deque
import sys

sys.setrecursionlimit(10**6)

R, C = map(int, input().split())
sy, sx = 1, 1
gy, gx = R, C

field = [["#"] * (C + 2)] + \
        [list("#" + input() + "#") for i in range(R)] + \
        [["#"] * (C + 2)]
dxy = [(0,1), (0,-1), (1,0), (-1,0)]
flg = False
cnt = 0

dot_num = sum(r.count('.') for r in field)

q = deque()
q.append([sy, sx])
field[sy][sx] = 0

while flg == False:
    yx = q.popleft()
    cnt = field[yx[0]][yx[1]]
    for dy, dx in dxy:
        y_n, x_n = yx[0] + dy, yx[1] + dx
        if y_n == gy and x_n == gx:
            field[y_n][x_n] = cnt + 1
            flg = True
            print(dot_num - (cnt+2))
            break
        if field[y_n][x_n] == '#':
            continue
        if field[y_n][x_n] == '.':
            q.append([y_n, x_n])
            field[y_n][x_n] = cnt + 1
    if flg:
        break
if flg == False:
    print(-1)

### FIXED CODE ###

from collections import deque
 
 
def dfs(field):
    q = deque([(0, 0, 0)])
    visited = [[False] * w for _ in range(h)]
    while q:
        i, j, d = q.popleft()
        if i == h - 1 and j == w - 1:
            return d
        if visited[i][j]:
            continue
        visited[i][j] = True
        if i > 0 and field[i - 1][j] == '.':
            q.append((i - 1, j, d + 1))
        if i < h - 1 and field[i + 1][j] == '.':
            q.append((i + 1, j, d + 1))
        if j > 0 and field[i][j - 1] == '.':
            q.append((i, j - 1, d + 1))
        if j < w - 1 and field[i][j + 1] == '.':
            q.append((i, j + 1, d + 1))
    else:
        return -1
 
 
h, w = map(int, input().split())
field = [input() for _ in range(h)]
dot_cnt = sum(r.count('.') for r in field)
d = dfs(field)
if d == -1:
    print(-1)
else:
    print(dot_cnt - (d+1))
def dfs(r, c, n):
    if board[r][c] == n:
        return
    if board[r][c] in 'WB':
        pile.append(board[r][c])
        return 
    board[r][c] = n
    drc = [(-1, 0), (0, 1), (1, 0), (0, -1)]
    for dr, dc in drc:
        nr, nc = r + dr, c + dc
        if 0 <= nr < h and 0 <= nc < w:
            dfs(nr, nc, n)

while True:
    w, h = map(int, input().split())
    if w == 0 and h == 0: break
    board = [list(input()) for _ in range(h)]
    place = 0
    piles = []
    black, white = [], []
    for r in range(h):
        for c in range(w):
            if board[r][c] == '.':
                pile = []
                place += 1
                dfs(r, c, place)
                piles.append(pile)
    for i, pile in enumerate(piles):
        if not pile: continue
        for p in pile:
            if p != 'B':
                break
        else:
            black.append(i+1)
        for p in pile:
            if p != 'W':
                break
        else:
            white.append(i+1)
    ans_b, ans_w = 0, 0
    for row in board:
        for c in row:
            if c in black:
                ans_b += 1
            elif c in white:
                ans_w += 1
    print(ans_b, ans_w)

### FIXED CODE ###

import sys
sys.setrecursionlimit(3000)
def dfs(r, c, n):
    board[r][c] = n
    drc = [(-1, 0), (0, 1), (1, 0), (0, -1)]
    for dr, dc in drc:
        nr, nc = r + dr, c + dc
        if 0 <= nr < h and 0 <= nc < w and board[nr][nc] != n:
            if board[nr][nc] in 'WB':
                pile.append(board[nr][nc])
                continue
            dfs(nr, nc, n)

while True:
    w, h = map(int, input().split())
    if w == 0 and h == 0: break
    board = [list(input()) for _ in range(h)]
    place = 0
    piles = []
    black, white = [], []
    for r in range(h):
        for c in range(w):
            if board[r][c] == '.':
                pile = []
                place += 1
                dfs(r, c, place)
                piles.append(pile)

    for i, pile in enumerate(piles):
        if not pile: continue
        if all(p == 'B' for p in pile):
            black.append(i+1)
        elif all(p == 'W' for p in pile):
            white.append(i+1)

    ans_b, ans_w = 0, 0
    for row in board:
        for c in row:
            if c in black:
                ans_b += 1
            elif c in white:
                ans_w += 1
    print(ans_b, ans_w)
from functools import reduce
def gcd(a, b):
  if (b == 0):
    return a;

  return gcd(b, a % b)


def lcm(a, b):
  return a * b / gcd(a, b);
def main():
  
  n = int(input())
  li = []
  for i in range(n):
    inp = int(input())
    li.append(inp)

  ans = int(reduce((lambda x, y: lcm(x, y)), li))
  if ans > 1e18:
    ans = 1e18
  print(ans)

if __name__ == "__main__":
  main()

### FIXED CODE ###

from functools import reduce

# def gcd(a, b):
#   if (b == 0):
#     return a
#   return gcd(b, a % b)

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

def lcm(a, b): 
    def gcd(a, b):  # a >= b
        if b == 0:
            return a
        else:
            return gcd(b, a % b)
    
    return a * b // gcd(a, b)

def main():
  n = int(input())
  li = []
  for i in range(n):
    inp = int(input())
    li.append(inp)

  ans = int(reduce((lambda x, y: lcm(x, y)), li))
  if ans > 1000000000000000000:
    ans = 1000000000000000000
  print(ans)

if __name__ == "__main__":
  main()
N, M = map(int, input().split())
S = list(input())

n = 0
next_n = 0
move = []
while n != N:
    for i in range(M, 0, -1):
        if n + i > N:
            continue

        if S[n + i] != '1':
            n = n + i
            move.append(i)
            break
    else:
        print(-1)
        exit()


i = len(move) - 1
move.sort(reverse=True)
n = 0
ans = []
while move:
    if S[n + move[i]] != '1':
        ans.append(move[i])
        n += move[i]
        del move[i]
        i = len(move) - 1
    else:
        i -= 1

print(*ans)


### FIXED CODE ###

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


# 後ろから貪欲
ans = []
position = N
while position > 0:
    for move in range(M, 0, -1):
        if position - move < 0:
            continue

        if S[position - move] == '1':
            continue

        ans.append(move)
        position -= move
        break
    else:
        print(-1)
        exit()

print(*ans[::-1])
ans = 1
while ans <= int(input())//2:
  ans *= 2
print(ans)

### FIXED CODE ###

n = int(input())
ans = 1
while ans <= n//2:
  ans *= 2
print(ans)
N = int(input())
B = []
for i in range(N):
    s,p = map(str,input().split())
    tmp = [i+1,s,int(p)]
    B.append(tmp)
B.sort(key=lambda x:x[2],reverse=True)
B.sort(key=lambda x:x[1])
for x in B:
    print(x[0])


### FIXED CODE ###

a,p=map(int,input().split())
print((3*a+p)//2)
L = input()
LL = L / 3
print(LL ** 3)

### FIXED CODE ###

L = input()
LL = float(L) / 3
print(LL ** 3)
A = []
for i in range(5):
  str = input()
  A[i] = int(str)
K = int( input() )

if( A[5] - A[0] > K):
  print("Yay!")
else:
  print(":(")
  
  
  

### FIXED CODE ###

A = []
for i in range(5):
  str = input()
  A.append(int(str))
K = int( input() )

if( A[4] - A[0] <= K):
  print("Yay!")
else:
  print(":(")
yobi = ["SUN","MON","TUE","WED","THU","FRI","SAT"]
yobi = yobi.reverse()
s = input()
for i in range(7):
  if s == yobi[i]:
    print(i+1)

### FIXED CODE ###

yobi = ["SUN","MON","TUE","WED","THU","FRI","SAT"]
yobi.reverse()
s = input()
for i in range(7):
  if s == yobi[i]:
    print(i+1)
K = int(input())
A, B = map(int,input.spilt())
if(A<=B/K*K){
  print("OK")
}
else{
  print("NG")
}

### FIXED CODE ###

N = int(input())
A, B = map(int, input().split())
for i in range(A, B+1):
  if i % N == 0:
    print('OK')
    break
else:
  print('NG')
n = input()
m = n % 10

if m == 2 or m == 4 or m == 5 or m == 7 or m == 9:
  print(hon)
elif m == 3:
  print(bon)
else:
  print(pon)

### FIXED CODE ###

n = int(input())
m = n % 10

if m == 2 or m == 4 or m == 5 or m == 7 or m == 9:
  print("hon")
elif m == 3:
  print("bon")
else:
  print("pon")
figure=input()
math=input()
flg=False
 
figure=figure.split(' ')
if math[3]>math[4]:
  flg=True
  
for i in range(len(math)-1):
  if math[i]=='#' and math[i+1]=='#':
    print('No')
    exit()
    
  if flg and i>=int(figure[2]-1) and i<int(figure[4])-1 and math[i]=='.' and math[i+1]=='.' and math[i+2]=='.':
    flg=False

if not flg:
	print('Yes')
else:
  print('No')

### FIXED CODE ###

figure=input()
math=input()
flg=False
 
figure=figure.split(' ')
if figure[3]>figure[4]:
  flg=True
  
for i in range(max(int(figure[3]),int(figure[4]))-1):
  if math[i]=='#' and math[i+1]=='#':
    if i>int(figure[1]) and i<int(figure[3])-1 or i>int(figure[2]) and i<int(figure[4])-1:
    	print('No')
    	exit()
    
  if flg and i>=int(figure[2])-2 and i<int(figure[4])-1 and math[i]=='.' and math[i+1]=='.' and math[i+2]=='.':
    flg=False

if not flg:
	print('Yes')
else:
  print('No')
n = int(input())
s = input()

from collections import Counter
c = Counter(s)
c = list(c.values())
ans = c[0] * c[1] * c[2]
# print(ans)
for k in range(n):
    for a in range(1, n//2 + 1):
        if k + 2 * a >= n:
            continue
        if (s[k] != s[k+a]) and (s[k+a] != s[k + 2 * a]) and (s[k] != s[k + 2*a]):
            ans -= 1

print(ans)

### FIXED CODE ###

# %%time
from collections import Counter, deque
n = int(input())
s = input()


# n = 4000
# np.random.seed(1)
# s = np.random.randint(0, 3, n)
# s = (s)

c = Counter(s)
c = list(c.values())
if len(c) == 3:
    ans = c[0] * c[1] * c[2]
else:
    ans = 0
# print(ans)
if ans > 0:
    for k in range(n):
        for a in range(1, (n - k)//2 + 1):
            if k + 2 * a >= n:
                continue
            x, y,  = s[k], s[k + a]
            
            if x != y:
                z = s[k + 2 * a]
                if y != z:
                    if z != x:
                        ans -= 1

print(ans)
s=input()
t=input()
S=list(s)
T=list(t)
S.sort()
T.sort()
T.reverse()
s=str(S)
t=str(T)


a=True

for i in range(10):
    if s[i]>t[i]:
        a=False


if a: print("Yes")


### FIXED CODE ###

s=input()
t=input()
S=list(s)
T=list(t)
S.sort()
T.sort()
T.reverse()
s=str(S)
t=str(T)

if S<T:print("Yes")
else :print("No")
def trace(A,input_num):
    if i != input_num - 1:   
        for i in range(input_num):
            print(A[i],end = " ")
    else:
        print(A[i])
        
    print("\n")

def insertionSort(A,input_num):
    for i in range(input_num):
        v = A[i]
        j = i - 1
        while(j >= 0 and A[j] > v):
            A[j + 1] = A[j]
            j -= 1
        A[j + 1] = v
        trace(A,input_num)
        
        
input_num = int(input())
A = list(map(int, input().split()))

insertionSort(A,input_num)



### FIXED CODE ###

def insertionSort(A,input_num):
    for i in range(input_num):
        v = A[i]
        j = i - 1
        while(j >= 0 and A[j] > v):
            A[j + 1] = A[j]
            j -= 1
        A[j + 1] = v
        print(*A)
        
input_num = int(input())
A = list(map(int, input().split()))

insertionSort(A,input_num)
from fractions import gcd
import sys
sys.setrecursionlimit(10 ** 9)

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

def llcm(a):
  if len(a) == 1:
    return a
  elif len(a) == 2:
    return lcm(a[0],a[1])
  else:
    return lcm(a[0],llcm(a[1:]))
  
N,M = map(int,input().split())
A = list(map(int,input().split()))

B = set()
flag = False
for a in A:
  if (a//2)%2 == 1 and (a//2) >=3:
    flag = True
  B.add(a//2)

l = llcm(list(B))
#print(l)
if l > M:
  ans = 0
else:
  ans = 1+(M-l)//(2*l)
if not flag:
  ans = max(ans-1,0)
print(ans)


### FIXED CODE ###

from fractions import gcd

def lcm(a, b):
  return a * b // gcd(a, b)
  
N,M = map(int,input().split())
A = list(map(int,input().split()))

B = set()
l = 1
for i in range(len(A)):
  c = 0
  a = A[i]
  while(a%2 == 0):
    a //= 2
    c += 1
  if i == 0:
    c0 = c
  else:
    if c0 != c:
      print(0)
      exit()
  l = lcm(l,A[i]//2)

print((M+l)//(2*l))
inData = int(input())

seqData = list(range(1,inData+1,1))
outData = [0] * inData
for thisData in seqData:
    if thisData == inData:
        if thisData%3 == 0 or thisData%10==3 or int((thisData/10))%10==3:
            print(" "+str(thisData))
        else:
            print(" "+""\n")
    else:
        if thisData%3 == 0 or thisData%10==3 or int((thisData/10))%10==3:
            print(" "+str(thisData), end = "")
        else:
            pass


### FIXED CODE ###

inData = int(input())

seqData = list(range(1,inData+1,1))
outData = [0] * inData
for thisData in seqData:
    if thisData == inData:
        if thisData%3 == 0 or thisData%10==3:
            print(" "+str(thisData))
        else:
            for i in range(5):
                i=i+1
                over =  10 ** i
                tmp = thisData/over
                if int(tmp % 10) == 3:
                    print(" "+str(thisData))
                    break
                else:
                    pass
            print("")
    else:
        if thisData%3 == 0 or thisData%10==3:
            print(" "+str(thisData), end = "")
        else:
            for i in range(5):
                i=i+1
                over =  10 ** i
                tmp = thisData/over
                if int(tmp % 10) == 3:
                    print(" "+str(thisData), end = "")
                    break
                else:
                    pass
a,b = map(int,input().split())
if a*b%2=0:
  print('Even')
else:
   print('Odd')

### FIXED CODE ###

a,b = map(int,input().split())
if (a*b) % 2 == 0:
  print('Even')
else:
  print('Odd')
a,b,h=map(int,input().split());print((a+b)*h/2)

### FIXED CODE ###

print((int(input())+int(input()))*int(input())//2)
#ユークリッドの互除法( A < B　とし, O(logA))
def gcd(a,b):
    if b == 0:
        return a
    else:
        return gcd(b, a%b)

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

#3個以上の最大公約数を求める必要がある
# res=0 と初期化して、res=gcd(res,x[i])と更新する
# gcd(a,b,c,....) → gcd(gcd(gcd(a,b),c),...) 
res = 0
x = list(map(int,input().split()))

for i in range(N):
    res = gcd(res,abs(x[i] - X))

print(res)


### FIXED CODE ###


import math
import fractions

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

print((x * y) // fractions.gcd(x, y))
n = int(input())
x = (n//1000) + 1
if n%1000=0:
  print(0)
else:
  print(x*1000-n)

### FIXED CODE ###

n = int(input())
x = (n//1000) + 1
if n%1000==0:
  print(0)
else:
  print(x*1000-n)
a,b=map(int,input())
print(a*b (a+b)*2)

### FIXED CODE ###

a,b=map(int,input().split())
print(a*b,(a+b)*2)
INF = 10**10
arr = [INF,2,5,5,4,5,6,3,7,6]
N,M = map(int,input().split())
src = sorted(list(map(int,input().split())))

dp = [-INF]*(N+1)
dp[0] = 0
for i in range(N):
    for j in src:
        if i + arr[j] <= N:
            dp[i + arr[j]] = max(dp[i + arr[j]], dp[i] + 1)
ans = ''
while(N > 0):
    for i in src[::-1]:
        if dp[N-arr[i]] == dp[N] - 1:
            ans += str(i)
            N -= arr[i]
            break
print(ans if ans else 0)

### FIXED CODE ###

INF = 10**10
arr = [INF,2,5,5,4,5,6,3,7,6]
N,M = map(int,input().split())
src = sorted(list(map(int,input().split())))

dp = [-INF]*(N+1)
dp[0] = 0
for i in range(N):
    for j in src:
        if i + arr[j] <= N:
            dp[i+arr[j]] = max(dp[i+arr[j]],dp[i] + 1)
dim = dp[N]
ans  = ''
while(dim > 0):
    for i in src[::-1]:
        if N >= arr[i] and dp[N-arr[i]] + 1 == dp[N]:
            ans += str(i)
            N -= arr[i]
            dim -= 1
            break
print(ans)