Harryxun/stf_run huggingface dataset:
# D
N, W = map(int, input().split())
 
import numpy as np

dp = np.zeros((N+1, W+1))

for i in range(1, N+1):
    w, v = map(int, input().split())
    dp[:w] = np.max(dp[0:W-w]+v[w:], dp[w:])

    print(dp[-1])
    

### FIXED CODE ###

# D
N, W = map(int, input().split())

import numpy as np
dp = np.zeros(W+1, dtype="int64")

for i in range(1, N+1):
    w, v = map(int, input().split())
    dp[w:] = np.maximum(dp[w:], dp[0:W-w+1] + v)

print(dp[-1])
n,k = map(int,input().split())
p = list(map(int,input().split()))
c = list(map(int,input().split()))
p = [i-1 for i in p]


groups = []
is_appear = [False]*n
group_size = [0]*n
for i in range(n):
    if is_appear[i]:
        continue
    group = []
    group.append(i)
    is_appear[i] = True
    j = p[i]
    while j != i:
        group.append(j)
        is_appear[j] = True
        j = p[j]
        
    groups.append(group)
    
    for i in group:
        group_size[i] = len(group)


cycle_score = [0]*n
for g in groups:
    score = 0
    for i in range(len(g)):
        score += c[g[i]]
    
    for i in g:
        cycle_score[i] = score

best = 0        
for i in range(n):
    score = 0
    best_i = 0
    cyc_num = k//group_size[i]
    if cycle_score[i]>0 and cyc_num>=1:
        remain = k-group_size[i]*(cyc_num-1)
        score += cycle_score*(cyc_num-1)
        
    elif cycle_score[i]<=0:
        remain = group_size[i]
    elif cyc_num<1:
        remain = k
    
    j = i
    for _ in range(remain):
        j = p[j]
        score += c[j]
        best_i = max(best_i,score)
    best = max(best,best_i)
    
print(best)

### FIXED CODE ###

n,k = map(int,input().split())
p = list(map(int,input().split()))
c = list(map(int,input().split()))
p = [i-1 for i in p]


groups = []
is_appear = [False]*n
group_size = [0]*n
for i in range(n):
    if is_appear[i]:
        continue
    group = []
    group.append(i)
    is_appear[i] = True
    j = p[i]
    while j != i:
        group.append(j)
        is_appear[j] = True
        j = p[j]
        
    groups.append(group)
    
    for i in group:
        group_size[i] = len(group)


cycle_score = [0]*n
for g in groups:
    score = 0
    for i in range(len(g)):
        score += c[g[i]]
    
    for i in g:
        cycle_score[i] = score

best = -float('inf')        
for i in range(n):
    score = 0
    best_i = -float('inf')
    cyc_num = k//group_size[i]
    if cycle_score[i]>0 and cyc_num>=1:
        remain = k-group_size[i]*(cyc_num-1)
        score += cycle_score[i]*(cyc_num-1)
        
    elif cycle_score[i]<=0:
        remain = group_size[i]
    elif cyc_num<1:
        remain = k
    
    j = i
    for _ in range(remain):
        j = p[j]
        score += c[j]
        best_i = max(best_i,score)
    best = max(best,best_i)
    
print(best)
N,K = input().split()
H = input().split()

if N < K:
    times = N
else:
    times = K

for i in range(times):
    H.remove(max(H))

print(sum(H))

### FIXED CODE ###

enemmyCountN,killerTimeK = map(int,input().split())
enemyHp = list(map(int,input().split()))

enemyHp.sort()

resultEnemyCount = enemmyCountN - killerTimeK
countNormal = 0

if killerTimeK >= enemmyCountN:
    print(0)

else:
    for i in range(resultEnemyCount):
        countNormal += enemyHp[i]
    print(countNormal)
a,b,c,d=map(int,input().split())
m = list()
list.append(a*c)
list.append(a*d)
list.append(b*c)
list.append(b*d)
print(max(m))


### FIXED CODE ###

a,b,c,d=map(int,input().split())
m = list()
m.append(a*c)
m.append(a*d)
m.append(b*c)
m.append(b*d)
print(max(m))
import math
N, K = map(int, input().split())
A = sorted([int(a) for a in input().split()])

X = [0] * 45
for i in range(N):
    b = bin((1<<45)+A[i])
    # print(b)
    for j in range(45):
        if b[-j-1] == "1":
            X[j] += 1

# print(X)
ans = 0
for i in range(45):
    if 1<<i > K:
        break
    ans += max(X[i], N - X[i]) << i
    
def calc(k, t):
    # print(k, t)
    if t<0:
        return 0
    if k == 0 or int(math.log2(k)) < t:
        return X[t] * (2**t) + calc(k, t-1)
        
    a = k+1
    while a%2==0:
        a//=2
    if a == 1:
        ret = 0
        for i in range(45):
            if 1<<i > k:
                break
            ret += max(X[i], N - X[i]) << i
            # print(max(X[i], N - X[i]) << i, "=>", ret)
        return ret
    else:
        ll = int(math.log2(k))
        kk = 2**ll
        ret = kk * X[ll] + calc(kk-1, t-1)
        if X[ll] < N - X[ll]:
            ret2 = kk * (N - X[ll]) + calc(k-kk, t-1)
            ret = max(ret, ret2)
            
        return ret
        
if K == 0:
    print(sum(A))
else:
    print(calc(K, 2**(int(math.log2(K)))))

### FIXED CODE ###

N, K = map(int, input().split())
A = sorted([int(a) for a in input().split()])

X = [0] * 45
for i in range(N):
    b = bin((1<<45)+A[i])
    # print(b)
    for j in range(45):
        if b[-j-1] == "1":
            X[j] += 1

# print(X)
ans = 0
for i in range(45):
    if 1<<i > K:
        break
    ans += max(X[i], N - X[i]) << i
    
def intlog2(n):
    if n <= 0:
        return -1
    i = 0
    while 2**i <= n:
        i += 1
    return i-1
def calc(k, t):
    # print(k, t)
    if t<0:
        return 0
    if k == 0 or intlog2(k) < t:
        return X[t] * (2**t) + calc(k, t-1)
        
    a = k+1
    while a%2==0:
        a//=2
    if a == 1:
        ret = 0
        for i in range(45):
            if 1<<i > k:
                break
            ret += max(X[i], N - X[i]) << i
            # print(max(X[i], N - X[i]) << i, "=>", ret)
        return ret
    else:
        ll = intlog2(k)
        kk = 2**ll
        ret = kk * X[ll] + calc(kk-1, t-1)
        if X[ll] < N - X[ll]:
            ret2 = kk * (N - X[ll]) + calc(k-kk, t-1)
            ret = max(ret, ret2)
            
        return ret
        
if K == 0:
    print(sum(A))
else:
    print(calc(K, 44))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
n =  int(input())
lista = a+b+c
call_number = []
for i in range(n):
    k = int(input())
    call_number.append(k)
bingo_number_list = []
for m,n in enumerate(lista):
    if n in call_number:
        bingo_number_list.appedned(m)
    
lista  = [0,4,8]
list0 = [0,1,2]
list1 = [3,4,5]
list2 = [6,7,8]
list3 = [0,3,6]
list4 = [1,4,7]
list5 = [2,5,8]
list6 = [0,4,8]
list7 = [2,4,6]

for i in range(8):
    name = "list"+str(i)
    if set(name) <= set(lista):
        bingo += 1

if bingo > 0:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
n =  int(input())
lista = a+b+c
call_number = []
for i in range(n):
    k = int(input())
    call_number.append(k)
bingo_number_list = []
for m,n in enumerate(lista):
    if n in call_number:
        bingo_number_list.append(m)
    
list0 = [0,1,2]
list1 = [3,4,5]
list2 = [6,7,8]
list3 = [0,3,6]
list4 = [1,4,7]
list5 = [2,5,8]
list6 = [0,4,8]
list7 = [2,4,6]
bingo = 0
for i in range(8):
    if set(list0) <= set(bingo_number_list):
        bingo += 1
    if set(list1) <= set(bingo_number_list):
        bingo += 1
    if set(list2) <= set(bingo_number_list):
        bingo += 1
    if set(list3) <= set(bingo_number_list):
        bingo += 1
    if set(list4) <= set(bingo_number_list):
        bingo += 1
    if set(list5) <= set(bingo_number_list):
        bingo += 1
    if set(list6) <= set(bingo_number_list):
        bingo += 1
    if set(list7) <= set(bingo_number_list):
        bingo += 1

if bingo > 0:
    print("Yes")
else:
    print("No")
s = input()
n = len(s)

#左から順番に文字を結合していき+を入れるパターンと入れないパターンについて同様に文字を結合させていく
def dfs(i,f):
    if i == n-1:#すべての文字を使いきったらそのときの計算をする
        return sum(list(map(int,f.split("+"))))
    return dfs(i+1,f+s[i+1]) + dfs(i+2,f+"+"+s[i+1])#+を入れない場合、+をいれる場合
    
print(dfs(0,s[0]))

### FIXED CODE ###

s = input()
n = len(s)

#左から順番に文字を結合していき+を入れるパターンと入れないパターンについて同様に文字を結合させていく
def dfs(i,f):
    if i == n-1:#すべての文字を使いきったらそのときの計算をする
        return sum(list(map(int,f.split("+"))))
    return dfs(i+1,f+s[i+1]) + dfs(i+1,f+"+"+s[i+1])#+を入れない場合、+をいれる場合
    
print(dfs(0,s[0]))
WORDS = ['dream', 'dreamer', 'erase', 'eraser']


def main(s):
    for word in WORDS:
        if delete_word(s, word):
            print('YES')
            break
    else:
        print('NO')


def delete_word(s, word):
    if s.startswith(word):
        s = s[len(word):]
        if len(s) == 0:
            return True
        for word in WORDS:
            if delete_word(s, word):
                return True
    else:
        return False


if __name__ == "__main__":
    main(input())


### FIXED CODE ###

WORDS = ['dream', 'dreamer', 'erase', 'eraser']
REVERSED_WORDS = [word[::-1] for word in WORDS]


def main(s):
    i = 0
    while i < len(s):
        for word in REVERSED_WORDS:
            if s[i:].startswith(word):
                i += len(word)
                break
        else:
            print('NO')
            break
    else:
        print('YES')


if __name__ == "__main__":
    main(input()[::-1])
def fib_memo(n):
  memo = [0]*(n+1)
  def _fib(n):
    if n <= 1:
      return n
    if memo[n] != 0:
      return memo[n]
    memo[n] = _fib(n-1) + _fib(n-2)
    return memo[n]
  return _fib(n)
  
N, M = map(int, input().split())
A = [int(input()) for _ in range(M)]
# A = range(M)
B = range(M)

Ans = reduce(lambda a, b: a*b, B)
# Ans = 10
print(Ans % 1000000007)
    


### FIXED CODE ###

N, M = map(int, input().split())
A = [True] * (N+1)
for _ in range(M):
  idx = int(input())
  A[idx] = False

step = [0] * (N+1)
step[0] = 1
for i in range(1, N+1):
  if A[i]:
    step[i] = step[i-1] + step[i-2]
  else:
    step[i] = 0
print(step[N]%(10**9+7))
def main():
    n, *a = map(int, read().split())
    r = 0
    for i1, ae in enumerate(a):
        if (i1+1)&1 and ae&1:
            r += 1
    print(r)

if __name__ == '__main__':
    main()

### FIXED CODE ###

import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from copy import deepcopy

def main():
    n, *a = map(int, read().split())
    if n == 1:
        if a[0] % 2 == 1:
            print(1)
        else:
            print(0)
        sys.exit()
    r = 0
    for i1 in range(0,n,2):
        r += a[i1] % 2 == 1
    print(r)


if __name__ == '__main__':
    main()
S = input()
if len(S)==3 and S.count('A')==2 or S.count('B')==2:
  print('Yes')
else
print('No')

### FIXED CODE ###

S = input()
if len(S)==3 and S.count('A')==2 or S.count('B')==2:
  print('Yes')
else:
  print('No')
a,b = map(int,input().split())

if a>b:
  print("GREATER")
elif a==b:
  print("EQUAL")
  
else:
  print("LESS")

### FIXED CODE ###

a = int(input())
b = int(input())

if a>b:
  print("GREATER")
elif a==b:
  print("EQUAL")
  
else:
  print("LESS")
N,D,A = map(int,input().split())
import numpy as np
import math
XH = [list(map(int,input().split())) for _ in range(N)]
XH = sorted(XH)
ans = 0
ma = XH[-1][0]
l = np.array([0]*(ma+5))
for xh in XH:
  l[xh[0]]=xh[1]
  

for xh in XH:
  x = xh[0]
  if x+2*D<=ma:
    a = l[x]
    if a<=0:
      continue
    else:
      b = math.ceil(a/A)
      ans += b
      l[x:x+2*D+1:]-=b*a
  else:
    a = l[x]
    if a<=0:
      continue
    else:
      b=math.ceil(a/A)
      ans += b
      l[x::]-=b*a
      
print(ans)

### FIXED CODE ###

def main():
  N,D,A = map(int,input().split())
  XH = [list(map(int,input().split())) for _ in range(N)]
  XH = sorted(XH)
  ans = 0
  S = [0]*(N+1)
  x = XH[0][0]
  h = XH[0][1]
  j = 0
  b = (h+A-1)//A
  ans += b
  y = b*A
  while True:
    if j+1>=N:
      break
    if XH[j+1][0]<=x+2*D:
      j+=1
    else:
      break
  S[0]+=y
  S[j+1]-=y
  S[1]+=S[0]
  for i in range(1,N):
    xh = XH[i]
    h = xh[1]
    s = S[i]
    rec = h-s
    if rec<=0:
      S[i+1]+=s
      continue
    else:
      x = xh[0]
      j = max(j,i)
      while True:
        if j+1>=N:
          break
        if XH[j+1][0]<=x+2*D:
          j+=1
        else:
          break
      b = (rec+A-1)//A
      ans += b
      y = b*A
      S[i]+=y
      S[j+1]-=y
      S[i+1]+=s+y
  print(ans)
main()
N, X, Y = map(int, input().split())
X,Y = X-1, Y-1

ans = [0] * N
 
for i in range(N-1):
  for j in range(i+1, N):
    d = min(j-i, abs(i-X) + abs(j-Y) + 1)
    ans[d] += 1

print(*ans([1:], sep='\n'))

### FIXED CODE ###

N, X, Y = map(int, input().split())
X,Y = X-1, Y-1

ans = [0] * N
 
for i in range(N-1):
  for j in range(i+1, N):
    d = min(j-i, abs(i-X) + abs(j-Y) + 1)
    ans[d] += 1

print(*ans[1:], sep='\n')
a, b, x = map(int, raw_input().split())
ans = 0
for i in range(a, b+1):
    if i % x == 0:
        ans += 1
print ans

### FIXED CODE ###

a, b, x = map(int, raw_input().split())

ans = (b/x) - ((a-1)/x)

print ans
a = list(input())
b = []
for i in range(a):
  if i % 2 == 0:
    b.push(a[i])
print("".join(b))
  

### FIXED CODE ###

temp = input().split(" ")
mojis = list(temp[0])
ans = ""
for a in range(len(mojis)):
    if a % 2 == 0:
        ans = ans + mojis[a]
print(ans)
S = input()

def rec(s):
    leng = len(s)
    if leng==0:
        print('YES')
    else:
        if s[0:5]=="dream":
            if leng==5:
                rec(s[5:])
            else:
                if s[5:7]=="er":
                    if s[5:10]=="erase":
                        if leng==10:
                            rec(s[10:])
                        elif s[10]=="r":
                            rec(s[11:])
                        else:
                            rec(s[10:])
                    else:
                        rec(s[7:])
                else:
                    rec(s[5:])
        elif s[0:5]=="erase":
            if leng==5:
                rec(s[5:])
            else:
                if s[5]=="r":
                    rec(s[6:])
                else:
                    rec(s[5:])
        else:
            print('NO')
rec(S)

### FIXED CODE ###

S = input()
S = S[::-1]
l = ['dream','dreamer','erase','eraser']
L = []
pos = 0
f=True

for i in l:
    L.append(i[::-1])

while pos < len(S):
    no_match = True
    for candidate in L:
        if S[pos:pos+len(candidate)]==candidate:
            pos+=len(candidate)
            no_match =False
            break
    if no_match:
        f =False
        break


if f:
    print('YES')
else:
    print('NO')
#100 C - /\/\/\/ AC
import collections
n = int(input())
A = list(map(int,input().split()))

A1 = A[::2]
A2 = A[1::2]
cnt1 = collections.Counter(A1)
cnt2 = collections.Counter(A2)

items1 = list(cnt1.most_comon())
items2 = list(cnt2.most_comon())

if items1[0][0] != items2[0][0]:
    ans = (len(A1) - items1[0][1]) + (len(A2) - items2[0][1])
else:
    if len(items1) == len(items2) == 1:
        ans = min(len(A1),len(A2))

    else:
        ans1 = (len(A1) - items1[0][1]) + (len(A2) - items2[1][1])
        ans2 = (len(A1) - items1[1][1]) + (len(A2) - items2[0][1])
        ans = min(ans1,ans2)
print(ans)

### FIXED CODE ###

#100 C - /\/\/\/
import collections
n = int(input())
A = list(map(int,input().split()))

A1 = A[::2]
A2 = A[1::2]
cnt1 = collections.Counter(A1)
cnt2 = collections.Counter(A2)

items1 = list(cnt1.items())
items2 = list(cnt2.items())
items1 = sorted(items1,key = lambda x:x[1],reverse = True)
items2 = sorted(items2,key = lambda x:x[1],reverse = True)

if items1[0][0] != items2[0][0]:
    ans = (len(A1) - items1[0][1]) + (len(A2) - items2[0][1])
else:
    if len(items1) == len(items2) == 1:
        ans = min(len(A1),len(A2))

    else:
        ans1 = (len(A1) - items1[0][1]) + (len(A2) - items2[1][1])
        ans2 = (len(A1) - items1[1][1]) + (len(A2) - items2[0][1])
        ans = min(ans1,ans2)
print(ans)
# https://qiita.com/snow67675476/items/e87ddb9285e27ea555f8

def factorization(n):
  arr = []
  temp = n
  for i in range(2, int(-(-n**0.5//1))+1):
    if temp%i==0:
      cnt=0
      while temp%i==0:
        cnt+=1
        temp //= i
      arr.append([i, cnt])

  if temp!=1:
    arr.append([temp, 1])

  if arr==[]:
    arr.append([n, 1])

  return arr

def resolve():
  N = int(input())
  prime_factors = factorization(N)

  result = 0
  for prime_factor in prime_factors:
    if prime_factor[0] == 1:
      continue

    for count in range(2, 42):
      if prime_factor[1] < (count + 1)*count//2:
        result += count - 1
        break
  print(result)


if __name__ == "__main__":
  resolve()

### FIXED CODE ###

import numpy as np
import math
from decimal import Decimal

def resolve():
  S = input().split(" ")
  print(math.floor(int(S[0])*Decimal(S[1])))


if __name__ == "__main__":
  resolve()
def kouyaku(a,b):
    aa = max(a,b)
    bb = min(a,b)
    if bb == 0:
        return aa
    else:
        return kouyaku(bb,aa%bb)

N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

T.sort()
T.reverse()

ans = 0
for time in T:
    if ans:
        ans = int( ans * time / kouyaku(ans, time) )
    else:
        ans = time
    
print(ans)

### FIXED CODE ###

def kouyaku(a,b):
    aa = max(a,b)
    bb = min(a,b)
    if bb == 0:
        return aa
    else:
        return kouyaku(bb,aa%bb)

N = int(input())
T = []
for i in range(N):
    T.append(int(input()))

T.sort()

ans = T[0]
for time in T:
    kou = kouyaku(ans, time)
    if kou != time:
        ans = ans//kou * time
    
print(ans)
N, A = map(int, input().split())
X = list(map(int, input().split()))

X2 = [0]*N

for i in range(N):
    X2[i] = X[i] - A

C = Counter([0, X2[0]])

for x in X2[1:]:
    C2 = Counter()
    for s, c in C.items():
        C2[s+x] += c
    C += C2

print(C[0]-1)


### FIXED CODE ###

from collections import Counter

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

X2 = [0]*N

for i in range(N):
    X2[i] = X[i] - A

C = Counter([0, X2[0]])

for x in X2[1:]:
    C2 = Counter()
    for s, c in C.items():
        C2[s+x] += c
    C += C2

print(C[0]-1)
import math
from functools import reduce

def lcm_base(x, y):
    return (x * y) // math.gcd(x, y)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

n = int(input())
t = [int(input()) for i in range(n)]

print(lcm_list(t))

### FIXED CODE ###

import fractions
from functools import reduce
 
def lcm_base(x, y):
    return (x * y) // fractions.gcd(x, y)
 
def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)
 
n = int(input())
t = [int(input()) for i in range(n)]
 
print(lcm(*t))
def main(): 
    n = int(input())
    a = [ int(x) for x in input().split() ]

    d = {}
    for aa in a:
        d[aa] = d.get(aa, 0) + 1

    if d.get(0, 0) == n:
        print("Yes")
        return 0
    L = sorted(list(d.items()))
    if n % 3 == 0 and len(L) == 2 and (L[0][0] == 0 and L[0][1] == n//3) and L[1][1] == n//3*2:
        print("Yes")
        return 0
    
    if n % 3 == 0 and len(L) == 3 and L[0][1] == n//3 and L[1][1] == n//3 and :[2][1] == n//3 and L[0][0]^L[1][0]^L[2][0] == 0:
        print("Yes")
        return 0

    print("No")

main()


### FIXED CODE ###

def main(): 
    n = int(input())
    a = [ int(x) for x in input().split() ]

    d = {}
    for aa in a:
        d[aa] = d.get(aa, 0) + 1

    if d.get(0, 0) == n:
        print("Yes")
        return 0
    L = sorted(list(d.items()))
    if n % 3 == 0 and len(L) == 2 and (L[0][0] == 0 and L[0][1] == n//3) and L[1][1] == n//3*2:
        print("Yes")
        return 0
    
    if n % 3 == 0 and len(L) == 3 and L[0][1] == n//3 and L[1][1] == n//3 and L[2][1] == n//3 and L[0][0]^L[1][0]^L[2][0] == 0:
        print("Yes")
        return 0

    print("No")

main()
#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys

def dist(h, l, r):
    st = [(l, 0)]
    while len(st) > 0:
        i, d = st.pop()
        if i == r:
            break
        if not h[i][r]:
            st.append((r, d + h[i][r]))
            continue
        for j in range(r):
            if not h[i][j] or i == j:
                continue
            st.append((j, d + h[i][j]))

    return st[-1] if len(st) > 0 else -1


def main():
    (n, m) = tuple(map(int, input().split()))
    lrds = tuple(map(int, input().split()) for _ in range(m))

    h = [[None] * n] * n
    for lrd in lrds:
        (l, r, d) = lrd
        if not h[l][l]:
            h[l][l] = 0
        if not st[r][r]:
            h[r][r] = 0
        pd = dist(h, l, r)
        if pd != -1 and pd != d:
            print('No')
            sys.exit()
        h[l][r] = d
        h[r][l] = -d

    print('Yes')

if __name__ == '__main__':
    main()


### FIXED CODE ###

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys

def main():
    n, m = map(int, sys.stdin.readline().split())
    lrds = ((map(int, line.split())) for line in sys.stdin.readlines())

    g = tuple([] for _ in range(n))
    x = [None] * n

    for l, r, d in lrds:
        l -= 1
        r -= 1
        g[l].append((r, d))
        g[r].append((l, -d))

    for i in range(n):
        if x[i] is not None:
            continue
        stack = [i]
        x[i] = 0
        while len(stack):
            v = stack.pop()
            for u, d in g[v]:
                if x[u] is None:
                    stack.append(u)
                    x[u] = x[v] + d

    for v in range(n):
        for u, d in g[v]:
            if x[v] + d != x[u]:
                print('No')
                sys.exit()

    print('Yes')

if __name__ == '__main__':
    main()
from math import pi 
r = int(input())
S = pi * r ** 2 
L = 2 * pi * r
print("{0} {1}".format(S, L))

### FIXED CODE ###

import math
r = input()
r = float(r)
S = math.pi * r * r
L = 2 * math.pi * r
print("{0} {1}".format(round(S,6), round(L,6)))
#! python3
# circle.py

import math

r = int(input())
print("%.6f"%(pow(r, 2)*math.pi), "%.6f"%(2*r*math.pi))


### FIXED CODE ###

#! python3
# circle.py

import math

r = float(input())
print("%.6f"%(pow(r, 2)*math.pi), "%.6f"%(2*r*math.pi))
from math import atan, degrees


def main():
    a, b, x = map(int, input().split())

    full = a * a * b
    half = full * 0.5

    if x <= half:
        s = x / a
        ans = 90 - degrees(atan(2 * s / b ** 2))

    else:
        s = (full - x) / a
        ans = 90 - degrees(atan(a ** 2 / (2 * s)))

    print(ans)


if __name__ == "__main__":
    main()


### FIXED CODE ###

from math import atan, degrees


def main():
    a, b, x = map(int, input().split())

    full = a * a * b
    half = full * 0.5

    if x <= half:
        s = x / a
        ans = 90 - degrees(atan(2 * s / b ** 2))

    else:
        s = (full - x) / a
        if s != 0:
            ans = 90 - degrees(atan(a ** 2 / (2 * s)))
        else:
            ans = 0

    print(ans)


if __name__ == "__main__":
    main()
n, a, b = (int(x) for x in input().splint())
sum = n * a
if sum <= b :
  print(sum)
else :
  print(b)

### FIXED CODE ###

n, a, b = (int(x) for x in input().split())
sum = n * a
if sum <= b :
  print(sum)
else :
  print(b)
n = int(input())
s = list(input())
count = 0
for i in range (n-2):
    if s[i]=="A" and s[i+1]=="B" and s[i+2]=="C":
        count += 1
print(count)

### FIXED CODE ###

k,x = map(int,input().split())
if 500*k >= x:
  print('Yes')
else:
  print('No')
H,W=map(int,input().split())
A=[[int(i) for i in input().split()] for j in range(H)]
B=[[int(i) for i in input().split()] for j in range(H)]
dp=[[0 for j in range(W)] for i in range(H)]
M=161*161
dp[0][0]|=1<<(A[0][0]-B[0][0]+M)
dp[0][0]|=1<<(-A[0][0]+B[0][0]+M)

for i in range(H):
    for j in range(W):
        dij=abs(A[i][j]-B[i][j])
        if i>0:
            dp[i][j]|=dp[i-1][j]<<dij
            dp[i][j]|=dp[i-1][j]>>dij
        if j>0:
            dp[i][j]|=dp[i][j-1]>>dij
            dp[i][j]|=dp[i][j-1]<<dij
ans=[]
for i in range(M):
    if (1<<i)&dp[-1][-1]!=0:
        ans.append(abs(i-M))
print(min(ans))


### FIXED CODE ###

H,W=map(int,input().split())
A=[[int(i) for i in input().split()] for j in range(H)]
B=[[int(i) for i in input().split()] for j in range(H)]
dp=[[0 for j in range(W)] for i in range(H)]
M=161*161
dp[0][0]|=1<<(A[0][0]-B[0][0]+M)
dp[0][0]|=1<<(-A[0][0]+B[0][0]+M)

for i in range(H):
    for j in range(W):
        dij=abs(A[i][j]-B[i][j])
        if i>0:
            dp[i][j]|=dp[i-1][j]<<dij
            dp[i][j]|=dp[i-1][j]>>dij
        if j>0:
            dp[i][j]|=dp[i][j-1]>>dij
            dp[i][j]|=dp[i][j-1]<<dij
ans=[]
for k in range(2*M+1):
    if (1<<k)&dp[-1][-1]!=0:
        ans.append(abs(k-M))
print(min(ans))