Harryxun/stf_run huggingface dataset:
from collections import deque
 
H, W = map(int, input().split())
A = [list(input()) for i in range(H)]
 
que = deque()
INF = float('inf')
dx = [1, 0, -1, 0]
dy = [0, 1, 0 , -1]            
D = [[INF] * W for i in range(H)]

for i in range(H):
    for j in range(W):
        if A[i][j] == '#':
            que.append([i, j])
            D[i][j] = 0
                       
def bfs():
    while len(que) != 0:
        p = que.popleft()
        for i in range(4):
            nx = p[0] + dx[i]
            ny = p[1] + dy[i]
            if 0 <= nx < H and 0 <= ny < W and A[nx][ny] != '#' and D[nx][ny] == INF:
                que.append([nx, ny])
                D[nx][ny] = D[p[0]][p[1]] + 1
    
bfs()

ans = 0
for i in range(H):
    for j in range(W):
        tmp = D[i][j]
        ans = max(ans, tmp)
        
print(ans)

### FIXED CODE ###

from collections import deque
 
H, W = map(int, input().split())
A = [list(input()) for i in range(H)]
 
que = deque()
INF = float('inf')
dx = [1, 0, -1, 0]
dy = [0, 1, 0 , -1]            
D = [[INF] * W for i in range(H)]

for i in range(H):
    for j in range(W):
        if A[i][j] == '#':
            que.append([i, j])
            D[i][j] = 0
                       
def bfs():
    while len(que) != 0:
        p = que.popleft()
        for i in range(4):
            nx = p[0] + dx[i]
            ny = p[1] + dy[i]
            if 0 <= nx < H and 0 <= ny < W and A[nx][ny] != '#' and D[nx][ny] == INF:
                que.append([nx, ny])
                D[nx][ny] = D[p[0]][p[1]] + 1
    
bfs()

ans = 0
for i in range(H):
    for j in range(W):
        tmp = D[i][j]
        ans = max(ans, tmp)
        
print(ans)
def divisors(n):
    divisors = set({1, n})
    for i in range(2, int(n**0.5)+1):
        q, r = divmod(n, i)
        if not r:
            divisors.add(i)
            divisors.add(q)
    return divisors

n = int(input())
A = map(int, input().split())
B = (divisors(a) for a in A)
c = Counter(chain_from_iterable(B))
print(max(k for k, v in c.items() if v >= n-1))

### FIXED CODE ###

from fractions import gcd

n = int(input())
*A, = map(int, input().split())
B = A[::-1]
L, R = [0]*(n+1), [0]*(n+1)
for i in range(n):
    L[i+1] = gcd(L[i], A[i])
    R[i+1] = gcd(R[i], B[i])
L, R = L[:n], R[:n][::-1]
print(max(gcd(l, r) for l, r in zip(L, R)))
line = input()
num_a, num_b, num_c, num_k = [int(n) for n in line.split()]
numbers = [num_a, num_b, num_c]
numbers.sort(reverse=True)
numbers[0] *= 2**num_k
print(sum(numbers))

### FIXED CODE ###

line = input()
numbers = [int(n) for n in line.split()]
numbers.sort()
K = int(input())
N = numbers[-1]
for _ in range(K):
    N*=2
for num in numbers[:2]:
    N+=num
print(N)
#include <iostream>
using namespace std;

int main(){
	int A, B;
	cin >> A >> B;
	if(A * B % 2 == 0){
		cout << "No" << endl;
	}
	else{
		cout << "Yes" << endl;
	}
}

### FIXED CODE ###

A, B = map(int, input().split())
if A*B % 2 == 0:
	print("No")
else:
	print("Yes")
s = list(input())
if s[3] == '7':
  s = s[:3] + '8' + s[4:]
print(s)

### FIXED CODE ###

s = input()
if s[3] == '7':
  ans = s[:3] + '8' + s[4:]
else:
  ans = s
print(ans)
nums = input().split()
a = int(nums[1])
b = int(nums[3])
c = int(nums[8])
if a < b < c:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

nums = input().split()
a = int(nums[0])
b = int(nums[1])
c = int(nums[2])
if a < b < c:
    print('Yes')
else:
    print('No')
a,b=int(input())

if a<=10 && b<=10:
  print(a*b)
else:
  print(-1)

### FIXED CODE ###

a,b=(int(x) for x in input().split())
 
if a<=9 and b<=9:
  print(a*b)
else:
  print(-1)
a=list(map(int, input().split()))
l=[a[0]]
if a[0]==1:
    print(0)
    exit()
elif a[0]==0:
    print(0)
    exit()
elif a[1]==1:
    print(0)
    exit()
def d(a,b):
    if a<b:
        if min(l)>b-a:
            l.append(b-a)
            d(b-a,b)
        else:
            print(min(l))
            exit()
    elif b<a:
        if min(l)>a-b:
            l.append(a-b)
            d(a-b,b)
        else:
            print(min(l))
            exit()
    else:
        print(0)
        exit()
d(a[0],a[1])

### FIXED CODE ###

a=list(map(int, input().split()))
def d(a,b):
    _1=a%b
    _2=b-(a%b)
    if _1<_2:
        print(_1)
    else:
        print(_2)
d(a[0],a[1])
n = int(input())
print(n - n //2) / n

### FIXED CODE ###

n = int(input())
print((n - n //2) / n)
import math
import collections
import fractions
import itertools
import functools
import operator

def ncr(n, r):
    if n < r: return 0
    r = min(r, n-r)
    if r == 0:
        return 1
    numer = functools.reduce(operator.mul, range(n, n-r, -1), 1)
    denom = functools.reduce(operator.mul, range(1, r+1), 1)
    return numer / denom % (10 ** 9 + 7)

def solve():
    n, k = map(int, input().split())
    for i in range(1,k+1):
        ans = (ncr(k-1, i-1) * ncr(n-k+1, i)) % (10**9+7)
        print(int(ans))
    return 0

if __name__ == "__main__":
    solve()


### FIXED CODE ###

import math
import collections
import fractions
import itertools
import functools
import operator

def ncr(n, r):
    if n < r: return 0
    r = min(r, n-r)
    if r == 0:
        return 1
    numer = functools.reduce(operator.mul, range(n, n-r, -1), 1)
    denom = functools.reduce(operator.mul, range(1, r+1), 1)
    return numer // denom % (10 ** 9 + 7)

def solve():
    n, k = map(int, input().split())
    for i in range(1,k+1):
        ans = (ncr(k-1, i-1) * ncr(n-k+1, i)) % (10**9+7)
        print(int(ans))
    return 0

if __name__ == "__main__":
    solve()
A,B=map(int,input().split())
list=[1,2,3]
if A==list[0],B==list[1] or A==list[1],B==list[0]:
  print(list[2])
elif A==list[0],B==list[2] or A==list[2],B==list[0]:
  print(list[1])
else:
  print(list[0])


### FIXED CODE ###

a=int(input())
b=int(input())
print(6-a-b)
def main():
 s,t = input().split()
 a,b = int(input().split())
 u = input()
 if s == u:
     a -= 1
 else:
     b -= 1
 print(a,b)
main()

### FIXED CODE ###

def main():
 s,t = input().split()
 a,b = map(int,input().split())
 u = input()
 if s == u:
     a -= 1
 else:
     b -= 1
 print(a,b)
main()
import math

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3):
    """
    3点を通る円の中心と半径を取得
    """
    d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
    if d == 0:
      return (0, 0), 0
    x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
    y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
    r = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
    return (x, y), r
  
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
answer = []
if N == 2:
  xy1, xy2 = XY
  x1, y1 = xy1
  x2, y2 = xy2
  answer.append(((x2 - x1)**2 + (y2 - y1)**2)**0.5 / 2)
else:
  for i in range(N):
    xi, yi = XY[i]
    for j in range(i + 1, N):
      xj, yj = XY[j]
      for k in range(j + 1, N):
        xk, yk = XY[k]
        xy0, r = get_circle_center_and_radius(xi, yi, xj, yj, xk, yk)
        x0, y0 = xy0
        
        if r:
          flag = 1
          for ii in range(N):
            xii, yii = XY[ii]
            if ((x0 - xii)**2 + (y0 - yii)**2)**0.5 > r:
              flag = 0
              break
          if flag:
            answer.append(r)
print(min(answer))  

### FIXED CODE ###

import math

def get_circle_center_and_radius(x1, y1, x2, y2, x3, y3):
    """
    3点を通る円の中心と半径を取得
    """
    d = 2 * ((y1 - y3) * (x1 - x2) - (y1 - y2) * (x1 - x3))
    if d == 0:
      return (0, 0), 0
    x = ((y1 - y3) * (y1 ** 2 - y2 ** 2 + x1 ** 2 - x2 ** 2) - (y1 - y2) * (y1 ** 2 - y3 ** 2 + x1 ** 2 - x3 ** 2)) / d
    y = ((x1 - x3) * (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) - (x1 - x2) * (x1 ** 2 - x3 ** 2 + y1 ** 2 - y3 ** 2)) / -d
    r = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
    return (x, y), r
  
N = int(input())
XY = [list(map(int, input().split())) for _ in range(N)]
answer = []
if N == 2:
  xy1, xy2 = XY
  x1, y1 = xy1
  x2, y2 = xy2
  answer.append(((x2 - x1)**2 + (y2 - y1)**2)**0.5 / 2)
else:
  for i in range(N):
    xi, yi = XY[i]
    for j in range(i + 1, N):
      xj, yj = XY[j]      
      r = ((xi - xj)**2 + (yi - yj)**2)**0.5/2
      x0, y0 = ((xi + xj) / 2, (yi + yj) / 2)
      flag = 1
      for ii in range(N):
        xii, yii = XY[ii]
        if ((x0 - xii)**2 + (y0 - yii)**2)**0.5 > r:
          flag = 0
          break
      if flag:
        answer.append(r)

  for i in range(N):
    xi, yi = XY[i]
    for j in range(i + 1, N):
      xj, yj = XY[j]
      for k in range(j + 1, N):
        xk, yk = XY[k]
        xy0, r = get_circle_center_and_radius(xi, yi, xj, yj, xk, yk)
        x0, y0 = xy0
        
        if r:
          flag = 1
          for ii in range(N):
            xii, yii = XY[ii]
            if ((x0 - xii)**2 + (y0 - yii)**2)**0.5 > r:
              flag = 0
              break
          if flag:
            answer.append(r)
print(min(answer))
import itertools
import numpy as np
n,m,q=map(int, input().split())  
a=[list(map(int, input().split())) for i in range(m)]
b=[list(map(int, input().split())) for i in range(q)]

x=[[0]*(501) for i in range(501)]
x=np.array
for i in range(m):
    x[a[i][0],a[i][1]]+=1



for i in range(501):
    x[i] = list(itertools.accumulate(x[i]))
  
for i in range(501):
    x[:,i] = list(itertools.accumulate(x[:,i]))



for i in range(q):
    print(x[b[i][1],b[i][1]]-x[b[i][1],b[i][0]-1]-x[b[i][0-1,b[i][1]]+x[b[i][0-1,b[i][0-1])



 







### FIXED CODE ###

import itertools
import numpy as np
n,m,q=map(int, input().split())  
a=[list(map(int, input().split())) for i in range(m)]
b=[list(map(int, input().split())) for i in range(q)]

x=[[0]*(501) for i in range(501)]

for i in range(m):
    x[a[i][0]][a[i][1]]+=1



for i in range(501):
    x[i] = list(itertools.accumulate(x[i]))
  
x=np.array(x)
for i in range(501):
    x[:,i] = list(itertools.accumulate(x[:,i]))



for i in range(q):
    v1=b[i][0]
    v2=b[i][1]
    
    a1=x[v2,v2]
    a2=x[v2,v1-1]
    a3=x[v1-1,v2]
    a4=x[v1-1,v1-1]
    print(a1-a2-a3+a4)
n, m = [int(i) for i in input().split()]
a = []
for _ in range(m):
    a.append(int(input()))

ways = [0] * 3
ways[1] = 0 if 1 in a else 1
ways[2] = 0 if 2 in a else ways[1] + 1
for i in range(3, n+1):
    if i in a:
        ways.append(0)
    else:
        ways.append((ways[-2]+ways[-1])%(10**9+7))
    print(ways)

print(ways[n])


### FIXED CODE ###

n, m = [int(i) for i in input().split()]
a = []
broken = [False] * max(n+1, 3)
for _ in range(m):
    i = int(input())
    a.append(i)
    broken[i] = True

ways = [0] * 3
ways[1] = 0 if broken[1] else 1
ways[2] = 0 if broken[2] else ways[1] + 1
for i in range(3, n+1):
    if broken[i]:
        ways.append(0)
    else:
        ways.append((ways[-2]+ways[-1])%(10**9+7))

print(ways[n])
import numpy as np                       
                                         
N,K,*A = map(int, open(0).read().split())
A = np.array(A)                          
                                         
for _ in range(K):                       
    X = np.ones(N, int)                  
    for i, d in enumerate(A):            
        X[max(0, i-d):max(0, i)] += 1    
        X[i+1:i+d+1] += 1                
    if np.array_equal(X, A):             
        break                            
    A = X                                
                                         
print(" ".join(map(str, A)))             

### FIXED CODE ###

N,K,*A = map(int, open(0).read().split())
                                         
for _ in range(K):                       
    b = [0] * N                          
    for i, d in enumerate(A):            
        b[max(0, i-d)] += 1              
        if i+d+1 < N:                    
            b[i+d+1] -= 1                
    for i in range(1, N):                
        b[i] += b[i-1]                   
    if A == b:                           
        break                            
    A = b                                
                                         
print(" ".join(map(str, A)))
if __name__ == '__main__':
    x = int(input())
    y = int(input())
    z = int(input())
    lst = (x, y, z)

    a = max(lst)
    if a == x:
        b, c = y, z
    elif a == y:
        b, c = x, z
    elif a == z:
        b, c = x, y
    print(((a - (a // 2)) * b * c) - ((a // 2) * b * c))


### FIXED CODE ###

if __name__ == '__main__':
    x, y, z = (int(_) for _ in input().split(' '))
    a = max((x, y, z))
    if a == x:
        b, c = y, z
    elif a == y:
        b, c = x, z
    elif a == z:
        b, c = x, y
    print(abs(a // 2 * b * c - (a - a // 2) * b * c))
def main():
    # -*- coding: utf-8 -*-
    # 整数の入力
    a = int(input())
    # スペース区切りの整数の入力
    # b, c = map(int, input().split())
    # b, c = map(int, input())

    # # 文字列の入力
    # a = input()
    # 出力
    # print("{} {}".format(a+b+c, s))

    # mul = a

    if '7' in a:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    # main('123')
    main()
    

### FIXED CODE ###


def main():
    # -*- coding: utf-8 -*-
    # 整数の入力
    # a = int(input())
    # スペース区切りの整数の入力
    # b, c = map(int, input().split())
    # b, c = map(int, input())

    # # 文字列の入力
    a = input()
    # 出力
    # print("{} {}".format(a+b+c, s))

    # mul = a

    if '7' in a:
        print("Yes")
    else:
        print("No")


if __name__ == '__main__':
    # main('123')
    main()
n = int(input())
l = list(map(int, input().split()))
s = list(set(l))
all_sum = 0
count = {}
for i in range(len(s)):
    v = l.count(s[i])
    if v > 1:
        all_sum += v * (v - 1) // 2
        count[s[i]] = v
    else:
        count[l[i]] = 1
for i in range(len(l)):
    if count[l[i]] > 1:
        v = count[l[i]]
        print(all_sum - v * (v-1) // 2 + (v-1) * (v-2)//2)
    else:
        print(all_sum)

### FIXED CODE ###

import collections

def count_defaultdict(it):
    counter = collections.defaultdict(int)
    for x in it:
        counter[x] += 1
    return dict(counter)

_ = int(input())
l = list(map(int, input().split()))
all_sum = 0
count = count_defaultdict(l)
for _, v in count.items():
    all_sum += v * (v - 1) // 2
for i in range(len(l)):
    if count[l[i]] > 1:
        v = count[l[i]]
        print(all_sum - v * (v-1) // 2 + (v-1) * (v-2)//2)
    else:
        print(all_sum)
n = int(input())
C = [int(input()) for i in range(n)]
nc = 10 ** 5 + 3
mod = 10**9+7

A = [0] * n
B = [-1] * nc

A[-1] = 1
B[C[-1]] = n-1
# print(B)

for i in range(n-2, -1, -1):
    if B[C[i]] != -1 and B[C[i]] != i+1:
        A[i] = (A[i+1] + A[B[C[i]]]) % mod
    else:
        A[i] = A[i+1]
    B[C[i]] = i
    # print(A,B)

# print(A)
# print(B)
print(A[0])

### FIXED CODE ###

n = int(input())
C = [int(input()) for i in range(n)]
nc = 2 * 10 ** 5 + 3
mod = 10**9+7

A = [0] * n
B = [-1] * nc

A[-1] = 1
B[C[-1]] = n-1
# print(B)

for i in range(n-2, -1, -1):
    if B[C[i]] != -1 and B[C[i]] != i+1:
        A[i] = (A[i+1] + A[B[C[i]]]) % mod
    else:
        A[i] = A[i+1]
    B[C[i]] = i
    # print(A,B)

# print(A)
# print(B)
print(A[0])
i=0

flag=0
beforeTxy=[0,0,0]
while i<N:
  afterTxy=list(map(int,input().split()))
  #print(afterTxy)
  unk=afterTxy[0]-beforeTxy[0]-abs(afterTxy[1]-beforeTxy[1])-abs(afterTxy[2]-beforeTxy[2])
  unk2=afterTxy[0]-beforeTxy[0]-abs(afterTxy[1]-beforeTxy[1])

  if unk>=0 and unk%2!=0 and unk2%2!=0:
    flag=1
  beforeTxy=afterTxy
  i=i+1

if flag==0:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

N=int(input())
i=0
 
flag=0
beforeTxy=[0,0,0]
while i<N:
  afterTxy=list(map(int,input().split()))
  #print(afterTxy)
  #unk=afterTxy[0]-beforeTxy[0]-abs(afterTxy[1]-beforeTxy[1])-abs(afterTxy[2]-beforeTxy[2])
  #unk2=afterTxy[0]-beforeTxy[0]-abs(afterTxy[1]-beforeTxy[1])
  dt=afterTxy[0]-beforeTxy[0]
  dist=abs(afterTxy[1]-beforeTxy[1])+abs(afterTxy[2]-beforeTxy[2])
  #print(dt,dist)
  if dt < dist or dt%2!=dist%2:
    flag=1
  beforeTxy=afterTxy
  i=i+1
 
if flag==0:
  print("Yes")
else:
  print("No")
s=input().split()
num=int(input())
ans = []
for i <= len(s) in range(0, len(s) / num + 1):
  ans = ans.append(s[i])
print(ans)

### FIXED CODE ###

s=input().split()
num=int(input())
ans = ""
for i in range(0, len(s[0]), num):
  ans=ans+s[0][i]
print(ans)
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)

H, W = rl()
S = []
for i in range(H):
  s = rs()
  S.append(s + '#')
S.append('#'*(W+1))

tab = [[0 for _ in range(W+1)] for _ in range(H+1)]

for i in range(H):
  k = 0
  prev = -1
  for j in range(W+1):
    if S[i][j] == '#':
      n = j-prev-1
      while k < j:
        tab[i][k] += n
        k += 1
      tab[i][k] = 0
      k += 1
      prev = j

for j in range(W):
  k = 0
  prev = -1
  for i in range(H+1):
    if S[i][j] == '#':
      n = i-prev-1
      while k < i:
        tab[k][j] += n - 1
        k += 1
      tab[k][j] = 0
      k += 1
      prev = i

ans = 0
for i in range(H):
  for j in range(W):
    ans = max(ans, tab[i][j])
print(ans)


### FIXED CODE ###

import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 1000000007
sys.setrecursionlimit(1000000)

L = rs()

n = len(L)
dp = [[0]*2 for i in range(n+1)]
dp[0][0] = 1

for i in range(n):
	if L[i] == '0':
		dp[i+1][0] += dp[i][0] % mod # (0,0)
		dp[i+1][1] += dp[i][1] % mod # (0,0)
		dp[i+1][1] += dp[i][1]*2 % mod # (1,0), (0,1)
	else:
		dp[i+1][1] += dp[i][0] + dp[i][1] % mod # (0,0)
		dp[i+1][0] += dp[i][0]*2 % mod # (0,1), (1,0)
		dp[i+1][1] += dp[i][1]*2 % mod # (0,1), (1,0)
print((dp[n][0]+dp[n][1])%mod)
N, A, B = map(int, input().split())

a = int(N - B)

pritn(a)

### FIXED CODE ###

N, A, B = map(int, input().split())
ans = N //(A + B)*A
rem = N % (A +B)
ans += min(rem, A)

print(ans)
def resolve():
    from scipy.sparse.csgraph import shortest_path
    from scipy.sparse import csr_matrix, lil_matrix
    import numpy as np
    inf = 10**20
    n, m, l = map(int, input().split())
    if m == 0:
        q = int(input())
        for _ in range(q):
            print(-1)
        return
    edge = np.array([input().split() for _ in range(m)], dtype=np.int64).T
    a = csr_matrix((edge[2], (edge[:2] - 1)), shape=(n, n))
    x = shortest_path(a, directed=False)
    b = lil_matrix((n, n), dtype=np.int64)
    for i in range(n):
        for j in range(i + 1, n):
            if x[i, j] <= l:
                b[i, j] = 1
    b = b.tocsr()
    y = shortest_path(b, directed=False)
    q = int(input())
    for _ in range(q):
        s, t = map(int, input().split())
        p = y[s - 1, t - 1]
        print(int(p) - 1 if p < inf else -1)


if __name__ == "__main__":
    resolve()


### FIXED CODE ###

def resolve():
    from scipy.sparse.csgraph import floyd_warshall
    import numpy as np
    import sys
    input = sys.stdin.readline
    n, m, l = map(int, input().split())
    inf = 10 ** 20
    ar = np.zeros((n, n))
    for _ in range(m):
        a, b, c = map(int, input().split())
        ar[a - 1, b - 1] = c
        ar[b - 1, a - 1] = c
    x = floyd_warshall(ar)
    br = np.zeros((n, n))
    for i in range(n):
        for j in range(i + 1, n):
            if x[i, j] <= l:
                br[i, j] = 1
                br[j, i] = 1
    y = floyd_warshall(br)
    q = int(input())
    for _ in range(q):
        s, t = map(int, input().split())
        p = y[s - 1, t - 1]
        print(int(p) - 1 if p < inf else -1)


if __name__ == "__main__":
    resolve()
H,W = map(int,input().split())
for i in range(W):
    if i%2==0:
        if H%2==0:
            num += H//2
        else:
            num += H//2+1
    else:
        num += H//2
print(num)

### FIXED CODE ###

H,W = map(int,input().split())
if H==1 or W==1:
    print(1)
else:
    if H%2==0 or W%2==0:
        print(H*W//2)
    else:
        print(H*W//2+1)
&x=raw_input()
print(x**3)

### FIXED CODE ###

x=int(input())
print(x**3)
N, Q = map(int, input().split())
Edges = list([] for _ in range(N))
for i in range(N-1):
    a, b = map(int, input().split())
    Edges[a-1].append(b-1)
    Edges[b-1].append(a-1)
P = [0 for _ in range(N)]
for i in range(Q):
    p, x = map(int, input().split())
    P[p-1] += x

gone = [False for _ in range(N)]

def dfs(counter, count, cur_node):
    count += P[cur_node]
    gone[cur_node] = True
    counter[cur_node] += count
    for next_node in Edges[cur_node]:
        if gone[next_node]:
            continue
        dfs(counter, count, next_node)

counter = [0 for _ in range(N)]
dfs(counter, 0, 0)

for c in counter:
    print(c)

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)

N, Q = map(int, input().split())
Edges = list([] for _ in range(N))
for i in range(N-1):
    a, b = map(int, input().split())
    Edges[a-1].append(b-1)
    Edges[b-1].append(a-1)
P = [0 for _ in range(N)]
for i in range(Q):
    p, x = map(int, input().split())
    P[p-1] += x

gone = [False for _ in range(N)]

def dfs(counter, count, cur_node):
    count += P[cur_node]
    gone[cur_node] = True
    counter[cur_node] += count
    for next_node in Edges[cur_node]:
        if gone[next_node]:
            continue
        dfs(counter, count, next_node)

counter = [0 for _ in range(N)]
dfs(counter, 0, 0)

for c in counter:
    print(c)
string = list(input());
if (string[2] == string[3] && string[4] == string[5]):
	print("Yes");
  else:
    print("No");

### FIXED CODE ###

string = list(input());
if (string[2] == string[3]):
  if (string[4] == string[5]):
    print("Yes");
  else:
    print("No");
else:
  print("No");
'''
ITP-1_4-B
 ????????¢?????¨?????¨
?????? r ???????????¢?????¨?????¨?????????????±???????????????°?????????????????????????????????
 Input
??????????????° r ????????????????????????
 Output
??¢?????¨?????¨?????????????????????????????§????????£????????????????????????????????????????????????????°???°?????°??¨??????0.00001 ??\???????????????????????§?????????????????¨????????????
'''
# import
import math

# ?????°??????????????????
r=float(input())

# ?????¨????????????
?? = math.pi

# ????????¢???????±???????
outputData01 = r*r*??

# ?????¨????±???????
outputData02 = 2*r*??

# ?????????????????????
print("{0:.6f} {1:.6f}".format(outputData01, outputData02))

### FIXED CODE ###

'''
ITP-1_4-B
 ????????¢?????¨?????¨
?????? r ???????????¢?????¨?????¨?????????????±???????????????°?????????????????????????????????
 Input
??????????????° r ????????????????????????
 Output
??¢?????¨?????¨?????????????????????????????§????????£????????????????????????????????????????????????????°???°?????°??¨??????0.00001 ??\???????????????????????§?????????????????¨????????????
'''
# import
import math

# ?????°??????????????????
r=float(input())

# ?????¨????????????
pai = math.pi

# ????????¢???????±???????
outputData01 = r*r*pai

# ?????¨????±???????
outputData02 = 2*r*pai

# ?????????????????????
print("{0:.6f} {1:.6f}".format(outputData01, outputData02))