Harryxun/stf_run huggingface dataset:
N,K=map(int,input().split())
L=list(map(int,input().split()))
R=list()
if K>=N:
  sums=0
  c=[0]*K
  for i in range(N):
    sums+=L[i]
    sums%=K
    a=(sums-i-1)%K
    R.append(a)
    c[a]+=1
  ans=0
  for i in range(N):
    s=(K-R[i])%K
    if s!=0:
      ans+=c[s]
    else:
      ans+=c[s]-1
  print((ans//2)+c[0])
else:
  ans=0
  c=[0]*K
  sums=0
  for i in range(N):
    sums+=L[i]
    sums%=K
    a=(sums-i-1)%K
    R.append(a)
  for i in range(K-1):
    c[R[i]]+=1
  ans+=c[0]
  c[R[K-1]]+=1
  for i in range(N):
    if i<N-K:
      ans+=c[R[i]]-1
      c[R[i]]-=1
      c[R[i+K]]+=1
    else:
      ans+=c[R[i]]-1
      c[R[i]]-=1
  print(ans)

### FIXED CODE ###

N,K=map(int,input().split())
L=list(map(int,input().split()))
R=list()
if K>=N:
  sums=0
  c=dict()
  for i in range(N):
    sums+=L[i]
    sums%=K
    a=(sums-i-1)%K
    if a in c:
      c[a]+=1
    else:
      c[a]=1
  ans=0
  for i in c:
    ans+=(c[i]-1)*c[i]//2
  if 0 in c:
    print(ans+c[0])
  else:
    print(ans)
else:
  ans=0
  c=[0]*K
  sums=0
  for i in range(N):
    sums+=L[i]
    sums%=K
    a=(sums-i-1)%K
    R.append(a)
  for i in range(K-1):
    c[R[i]]+=1
  ans+=c[0]
  c[R[K-1]]+=1
  for i in range(N):
    if i<N-K:
      ans+=c[R[i]]-1
      c[R[i]]-=1
      c[R[i+K]]+=1
    else:
      ans+=c[R[i]]-1
      c[R[i]]-=1
  print(ans)
a, op, b = map(int, input().split())
if op == "+":
    print(a + b)
elif op == "-":
    print(a - b)
elif op == "*":
    print(a * b)
else:
    print(a / b)

### FIXED CODE ###

while True:
    a, op, b = map(str, input("").split())
    a = int(a)
    b = int(b)
    if op == "+":
        print(a + b)
    elif op == "-":
        print(a - b)
    elif op == "*":
        print(a * b)
    elif op == "/":
        print(a // b)
    elif op == "?":
        break
n = int(input())

def solve(n):
    res = 0
    for i in range(2, int(n ** 0.5) + 2):
        cnt = 0
        while n % pow(i, cnt + 1) == 0:
            n /= pow(i, cnt + 1)
            cnt += 1
            if n % pow(i, cnt + 1) != 0:
                res += cnt
                break
    
    if n != 1:
            res = 1
    
    return res

print(solve(n))


### FIXED CODE ###

a, b = map(int, input().split())
print(a * b)
n = int(input())
words = {}

for i in range(n) :
    new_word = input()
    if new_word in words.keys() :
        words[new_word] += 1
    else :
        words[new_word] = 1

mx_freq = max(words.values())
mx_words = [k for k in words.items() if words[k] == mx_freq]

mx_words.sort()

for mx_word in mx_words :
    print(mx_word)

### FIXED CODE ###

n = int(input())
dictionary = {}
for i in range(n) :
    new_word = input()
    if new_word in dictionary.keys() :
        dictionary[new_word] += 1
    else :
        dictionary[new_word] = 1

max_val = max(dictionary.values())
keys_of_max_val = [key for key in dictionary if dictionary[key] == max_val]

keys_of_max_val.sort()

for word in keys_of_max_val :
    print(word)
from collections import defaultdict as dt
def factorization(NUM,DICT):
    temp = NUM
    for i in range(2, int(-(-NUM**0.5//1))+1):
        if temp % i == 0:
            cnt = 0
            while temp % i == 0:
                cnt += 1
                temp //=i
            DICT[i] += cnt
    
    if temp != 1:
        DICT[temp] += 1
    return DICT
    
def nCr(n,r,mod):
    multiple_list = [i for i in range(n,n-r,-1)]
    devide_list = [i for i in range(r,0,-1)]
    
    multiple_dict = dt(int)
    devide_dict = dt(int)
    
    for multiple in multiple_list:
        multiple_dict = factorization(multiple,multiple_dict)
    for devide in devide_list:
        devide_dict = factorization(devide,devide_dict)
    
    for key in devide_dict:
        multiple_dict[key] -= devide_dict[key]
    
    ncr = 1
    
    for key in multiple_dict:
        ncr *= key ** multiple_dict[key]
        ncr %= mod
    
    return ncr
    
X,Y = [int(i) for i in input().split()]
def check(x,y):
    if x/2 == y:
        return 0
    elif x/2 < y:
        return 1
    else:
        return 9
cnt = 0
possible = True
MOD = 10**9 + 7

while True:
    check_num =  check(X,Y)
    if check_num == 0:
        break
    elif check_num == 1:
        X += 1
        Y -= 1
        cnt += 1
    else:
        possible = False
        break
if possible == True:
    n = X // 2 
    r = cnt
    print(nCr(n,r,MOD))
else:
    print(0)


### FIXED CODE ###

def getComb(n, k, MOD):
    if n < k:
        return 0
    if n-k < k:
        k = n-k
    comb = 1
    for x in range(n-k+1, n+1):
        comb = (comb * x) % MOD
    d = 1
    for x in range(1, k+1):
        d = (d * x) % MOD
    comb *= pow(d, MOD-2, MOD)
    return comb % MOD
    
X,Y = [int(i) for i in input().split()]
def check(x,y):
    if x/2 == y:
        return 0
    elif x/2 < y:
        return 1
    else:
        return 9
cnt = 0
possible = True
MOD = 10**9 + 7

while True:
    check_num =  check(X,Y)
    if check_num == 0:
        break
    elif check_num == 1:
        X += 1
        Y -= 1
        cnt += 1
    else:
        possible = False
        break
if possible == True:
    n = X // 2 
    r = cnt
    print(getComb(n,r,MOD))
else:
    print(0)
n = int(input)
l = list(map(int, input().split()))
x = max(l)
s = sum(l)
if x < (s-x):
    print("Yes")
else:
    print("No")

### FIXED CODE ###

n = int(input())
l = list(map(int, input().split()))
x = max(l)
s = sum(l)
if x < (s-x):
    print("Yes")
else:
    print("No")
a,b=map(int(input()).split())
if a==1:
    print(1)
elif a==2 and b<=1:
    print(1)
elif a==2 and b>=2:
    print(2)
elif a==3 and b<=2:
    print(2)
elif a==3 and b>=3:
    print(3)
elif a==4 and b<=3:
    print(3)
elif a==4 and b>=4:
    print(4)
elif a==5 and b<=4:
    print(4)
elif a==5 and b>=5:
    print(5)
elif a==6 and b<=5:
    print(5)
elif a==6 and b>=6:
    print(6)
elif a==7 and b<=6:
    print(6)
elif a==7 and b>=7:
    print(7)
elif a==8 and b<=7:
    print(7)
elif a==8 and b>=8:
    print(8)
elif a==9 and b<=8:
    print(8)
elif a==9 and b>=9:
    print(9)
elif a==10 and b<=9:
    print(9)
elif a==10 and b>=10:
    print(10)
elif a==11 and b<=10:
    print(10)
elif a==11 and b>=11:
    print(11)
elif a==12 and b<=11:
    print(11)
else:
    print(12)

### FIXED CODE ###

a,b=map(int, input().split())
if a==1:
    print(1)
elif a==2 and b<=1:
    print(1)
elif a==2 and b>=2:
    print(2)
elif a==3 and b<=2:
    print(2)
elif a==3 and b>=3:
    print(3)
elif a==4 and b<=3:
    print(3)
elif a==4 and b>=4:
    print(4)
elif a==5 and b<=4:
    print(4)
elif a==5 and b>=5:
    print(5)
elif a==6 and b<=5:
    print(5)
elif a==6 and b>=6:
    print(6)
elif a==7 and b<=6:
    print(6)
elif a==7 and b>=7:
    print(7)
elif a==8 and b<=7:
    print(7)
elif a==8 and b>=8:
    print(8)
elif a==9 and b<=8:
    print(8)
elif a==9 and b>=9:
    print(9)
elif a==10 and b<=9:
    print(9)
elif a==10 and b>=10:
    print(10)
elif a==11 and b<=10:
    print(10)
elif a==11 and b>=11:
    print(11)
elif a==12 and b<=11:
    print(11)
else:
    print(12)
st=input().split()
A=int(st[0])
B=int(st[1])
op=st[2]
if op=="+":
  print(A+B)
else:
  print(A-B)


### FIXED CODE ###

st=input().split()
A=int(st[0])
B=int(st[2])
op=st[1]
if op=="+":
  print(A+B)
else:
  print(A-B)
n = int(input())
d = list(map(int,input().split()))
m = int(input())
t = list(map(int,input().split()))
dd=[0]*(max(d)+1)
tt=[0]*(max(t)+1)
for i in range(n):
    dd[d[i]]+=1
for i in range(m):
    tt[t[i]]+=1
for i in range(m):
    if tt[t[i]]>dd[t[i]]:
        print("NO")
        exit()
print("YES")

### FIXED CODE ###

n = int(input())
d = list(map(int,input().split()))
m = int(input())
t = list(map(int,input().split()))
d.sort()
t.sort()
i=0
j=0
while i<m and j<n:
    if t[i]==d[j]:
        i+=1
        j+=1
    elif t[i]<d[j]:
        print("NO")
        exit()
    else:
        j+=1
print("YES")
import math
def lcm(a, b):
    return a * b // math.gcd(a, b)

def solve():
    a, b = list(map(int, input().split()))
    print(lcm(a, b))

if __name__ == "__main__":
    solve()

### FIXED CODE ###

from fractions import gcd

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

def solve():
    a, b = list(map(int, input().split()))
    print(lcm(a, b))

if __name__ == "__main__":
    solve()
a = list(map(lambda x: int(x), input().split(" ")))
b = list(set(a))
print(a-b)

### FIXED CODE ###

a = list(map(lambda x: int(x), input().split(" ")))
b = list(set(a))
if a.count(b[0]) == 2:
  print(b[1])
else:
  print(b[0])
#13:27
N = int(input())
A = list(map(int,input().split()))
ex_red = [0]*8
red_cnt = 0

for i in range(8):#0-7
    for j in range(N):
        if 400*i<=A[j] and A[j]<400*(i+1):
            ex_red[i]+=1

for i in range(N):
    if 3200 <= A[i]:
        red_cnt += 1
not_red_color = 0
for i in range(8):
    if ex_red[i] > 0:
        not_red_color += 1
    
zero_num = 8 - not_red_color

if red_cnt<=1:
    ans = red_cnt + not_red_color
else:#red_cnt more than 2
    assign = red_cnt - 1
    if zero_num >= assign:
        ans = assign + not_red_color + 1
    else:
        ans = zero_num + not_red_colot + 1

#if red_cnt != 0:
min_ans = not_red_color

# if zero_num >= red_cnt:
#     ans = red_cnt + not_red_color
# else:
#     ans = zero_num + not_red_color

print(min_ans, ans)


### FIXED CODE ###

#13:27
N = int(input())
A = list(map(int,input().split()))
ex_red = [0]*8
red_cnt = 0

for i in range(8):#0-7
    for j in range(N):
        if 400*i<=A[j] and A[j]<400*(i+1):
            ex_red[i]+=1
n = 0
for i in range(N):
    if 3200 <= A[i]:
        n += 1
not_red_color = 0
c = 0
for i in range(8):
    if ex_red[i] > 0:
        c += 1
#print(c)#soreigai_count
#print(n)#red_count

max_ans = n + c

#min_ans
if c >= 1:
    min_ans = c
elif c == 0:
    min_ans = 1
print(min_ans, max_ans)
n = int(input())
a = list(map(int,input().split()))



an = [0]
for i in range(n):
    an.append(a[i])       
an.append(0)

ifsums = 0
nal = []

for i in range(1,n+1):
    ifsums = ifsums + abs(a[i + 1]   - a[i])

for i in range(1,n+1):
    nal.append(ifsums - ( abs(an[i] - an[i-1]) + abs(an[i+1] - an[i]) - abs(an[i+1] -  an[i-1])  ))


for i in range(len(nal)):
    print(nal[i])




### FIXED CODE ###

n = int(input())
a = list(map(int,input().split()))



an = [0]
for i in range(n):
    an.append(a[i])       
an.append(0)

ifsums = 0
nal = []

for i in range(0,n+1):
    ifsums = ifsums + abs(an[i + 1]   - an[i])

for i in range(1,n+1):
    nal.append(ifsums - ( abs(an[i] - an[i-1]) + abs(an[i+1] - an[i]) - abs(an[i+1] -  an[i-1])  ))


for i in range(len(nal)):
    print(nal[i])
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
    
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
    a, b = map(int, input().split())
    uf.union(a−1, b−1)
print(uf.group_count() - 1)

### FIXED CODE ###

class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
    
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
    a, b = map(int, input().split())
    uf.union(a - 1, b - 1)
print(uf.group_count() - 1)
import collections

N,K,L=map(int,input().split())

RP=[i for i in range(N+1)]
Rsize=[1 for i in range(N+1)]
TP=[i for i in range(N+1)]
Tsize=[1 for i in range(N+1)]

def findR(a):
    if a==RP[a]:
        return a
    else:
        return findR(RP[a])
        
def findT(a):
    if a==TP[a]:
        return a
    else:
        return findT(TP[a])
        
def unionR(b,c):
    B=findR(b)
    C=findR(c)
    if Rsize[B]>=Rsize[c]:
        Rsize[B]+=Rsize[C]
        RP[C]=RP[B]
    else:
        Rsize[C]+=Rsize[B]
        RP[B]=RP[C]

def unionT(b,c):
    B=findT(b)
    C=findT(c)
    if Tsize[B]>=Tsize[c]:
        Tsize[B]+=Tsize[C]
        TP[C]=TP[B]
    else:
        Tsize[C]+=Tsize[B]
        TP[B]=TP[C]
        
for i in range(K):
    p,q=map(int,input().split())
    if findR(p)==findR(q):
        pass
    else:
        unionR(p,q)

for i in range(L):
    r,s=map(int,input().split())
    if findT(r)==findT(s):
        pass
    else:
        unionT(r,s)
        
L=collections.defaultdict(int)
for i in range(1,N+1):
    L[findR(i),findT(i)]+=1

ans=str(L[findR(1),findT(1)])
for i in range(2,N+1):
    ans+=" "+str(L[findR(i),findT(i)])
print(ans)


### FIXED CODE ###

N,K,L=map(int,input().split())
Road_P=[i for i in range(N+1)]
Road_size=[1 for i in range(N+1)]

def find_road(a):
    if a==Road_P[a]:
        return a
    else:
        return find_road(Road_P[a])
        
def union_road(b,c):
    B=find_road(b)
    C=find_road(c)
    if Road_size[B]>=Road_size[C]:
        Road_P[C]=Road_P[B]
        Road_size[B]+=Road_size[C]
    else:
        Road_P[B]=Road_P[C]
        Road_size[C]+=Road_size[B]

for i in range(K):
    p,q=map(int,input().split())
    if find_road(p)!=find_road(q):
        union_road(p,q)
#print(Road_P)

Rail_P=[i for i in range(N+1)]
Rail_size=[1 for i in range(N+1)]

def find_rail(a):
    if a==Rail_P[a]:
        return a
    else:
        return find_rail(Rail_P[a])
        
def union_rail(b,c):
    B=find_rail(b)
    C=find_rail(c)
    if Rail_size[B]>=Rail_size[C]:
        Rail_P[C]=Rail_P[B]
        Rail_size[B]+=Rail_size[C]
    else:
        Rail_P[B]=Rail_P[C]
        Rail_size[C]+=Rail_size[B]

for i in range(L):
    p,q=map(int,input().split())
    if find_rail(p)!=find_rail(q):
        union_rail(p,q)

#print(Rail_P)

comb={}
for i in range(1,N+1):
    if (find_road(i),find_rail(i)) in comb:
        comb[(find_road(i),find_rail(i))]+=1
    else:
        comb[(find_road(i),find_rail(i))]=1

#print(comb)

for i in range(1,N+1):
    print(comb[(find_road(i),find_rail(i))])
n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
  return (1+x)/2

a=[]
ans=0
f=0
for i in range(k):
  f+=g(p[i])
a.append(f)
for i in range(n-k+1):
  a.append(a[i]+g(p[k+i])-g(p[i]))
  ans=max(ans,a[i+1])
  
print(ans)

  
  


### FIXED CODE ###

n,k=map(int,input().split())
p=list(map(int,input().split()))
def g(x):
  return (1+x)/2

a=[]
ans=0
f=0
for i in range(k):
  f+=g(p[i])
a.append(f)
ans=f
for i in range(n-k):
  a.append(a[i]+g(p[k+i])-g(p[i]))
  ans=max(ans,a[i+1])
  
print(ans)
import itertools
import numpy as np
import copy

N, M, X = map(int, input().split())
CA = [list(map(int, input().split())) for _ in range(N)]
CA = np.array(CA)

ans = 10 ** 7
for i in itertools.product([0, 1], repeat=N):
    tCA = copy.copy(CA)
    for j in range(N):
        if i[j] == 0:
            tCA[j] = np.zeros(CA.shape[1])
    s = np.sum(tCA, axis=0)
    l = sum(k >= X for k in s[1:])
    if s[0] < ans and l == M:
        ans = s[0]

if ans == 10 ** 7:
    print(-1)
else:
    print(ans)


### FIXED CODE ###

import itertools
import numpy as np
import copy

N, M, X = map(int, input().split())
CA = [list(map(int, input().split())) for _ in range(N)]
CA = np.array(CA)

ans = 10 ** 7
for i in itertools.product([0, 1], repeat=N):
    tCA = copy.copy(CA)
    for j in range(N):
        if i[j] == 0:
            tCA[j] = np.zeros(CA.shape[1])
    s = np.sum(tCA, axis=0)
    l = sum(k >= X for k in s[1:])
    if s[0] < ans and l == M:
        ans = s[0]

if ans == 10 ** 7:
    print(-1)
else:
    print(ans)
n = int(input())
s = input()
if n % 2 == 0 and s[:n//2] == s[s//2:] :
  print('Yes')
else:
  print('No')

### FIXED CODE ###

n = int(input())
s = input()
if n % 2 == 0 and s[:n//2] == s[n//2:] :
  print('Yes')
else:
  print('No')
n = int(input())
numList = list()
for i in range(n):
    numList.append(int(input()))
sum, ctr = 0, 1
for i in numList:
    if i == 0: continue
    if i % 2 != 0 and ctr % 2 != 0:
        sum = sum + 1
    ctr = ctr + 1
print(sum)

### FIXED CODE ###

n = int(input())
S = list(map(int, input().split()))
ans = 0
for i in range(0, n, 2):
    if i%2 == 0 and S[i]%2 == 1:
        ans += 1
print(ans)
n,k = list(map(int, input("").split()))

sunuke = [0] * n
 
for i in range(K):
    d = int(input())
    a = list(map(int,input().split()))
    for j in a:
        sunuke[j-1] = 0

print(sum(sunuke))

### FIXED CODE ###

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

sunuke = [1] * n
 
for i in range(k):
    d = int(input())
    a = list(map(int, input().split()))
    for j in a:
        sunuke[j-1] = 0

print(sum(sunuke))
n = input()
n = int(n)
maxv = -20000000
list = []

i = 1
while(i<n):
	x = input()
	x = int(x)
	list = list.append(x)
	i = i + 1

minv = list[0]
i = 1
while(i<n):
	maxv = max(maxv, list[i]-minv)
	minv = min(minv, list[i])
	i = i + 1

print(maxv)


### FIXED CODE ###

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

i = 0
while(i<n):
	x = input()
	x = int(x)
	list.append(x)
	i = i + 1

maxv = -2000000000
minv = list[0]
i = 1
while(i<n):
        maxv = max(maxv, list[i]-minv)
        minv = min(minv, list[i])
        i = i + 1
	
print(maxv)
a,b = map(int, input())
ans = max(a + b, 2*a-1, 2*b-1)
print(ans)

### FIXED CODE ###

a,b = map(int, input().split())
ans = max(a + b, 2*a-1, 2*b-1)
print(ans)
def solve():
    from sys import stdin
    f_i = stdin
    
    N = int(f_i.readline())
    
    points = []
    for i in range(N):
        x, y = map(int, f_i.readline().split())
        points.append(x + y * 1j)
    
    radiuses = []
    from itertools import combinations
    for p1, p2 in combinations(points, 2):
        c = (p1 + p2) / 2
        r = abs(p1 - c)
        for p in points:
            if abs(p - c) > r:
                break
        else:
            radiuses.append(r)
    
    print(min(radiuses))

solve()

### FIXED CODE ###

def solve():
    from sys import stdin
    f_i = stdin
    
    N = int(f_i.readline())
    
    points = []
    for i in range(N):
        x, y = map(int, f_i.readline().split())
        points.append(x + y * 1j)
    
    from itertools import combinations
    radiuses = []
    
    for p1, p2 in combinations(points, 2):
        c = (p1 + p2) / 2
        r = abs(p1 - c)
        for p in points:
            if abs(p - c) > r:
                break
        else:
            radiuses.append(r)
    
    if radiuses:
        return min(radiuses)
    
    def circumcircle(a, b, c):
        n = (a - b) * abs(c) ** 2 + (b - c) * abs(a) ** 2 + (c - a) * abs(b) ** 2
        d = (a - b) * c.conjugate() + (b - c) * a.conjugate() + (c - a) * b.conjugate()
        return n / d # center of circumcircle
    
    err = 10 ** -7
    for p1, p2, p3 in combinations(points, 3):
        z1 = p3 - p1
        z2 = p2 - p1
        if z1.real * z2.imag == z1.imag * z2.real:
            continue
        
        c = circumcircle(p1, p2, p3)
        r = abs(p1 - c)
        for p in points:
            #if abs(p - c) > r:
            if abs(p - c) - r > err:
                break
        else:
            radiuses.append(r)
    
    return min(radiuses)

print(solve())
N,T = map(int,input().split())
l = [list(map(int,input().split())) for i in range(N)]
#print(l)
a = []
for i in range(N):
  if l[0][i] < T:
    a.append(l[0][i])
t = min(a)
print(t)

### FIXED CODE ###

N,T = map(int,input().split())
l = [list(map(int,input().split())) for i in range(N)]
##print(l)
a = []
for i in range(N):
  if l[i][1] <= T:
    a.append(l[i][0])
if a != []:
  t = min(a) 
  print(t)
else:
  print("TLE")
a = int(input())
b = int(input())

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")
# coding: utf-8
# Your code here!
import sys
sys.setrecursionlimit(10**7)

n,MOD = [int(i) for i in input().split()]

to = [[] for i in [0]*n]
for _ in range(n-1):
    x,y = [int(i)-1 for i in input().split()]
    to[x].append(y)
    to[y].append(x)


dp = [[0]*len(to_i) for to_i in to]
parent_index = [-1]*n 
ans = [0]*n

def dfs(v, p):
    """葉の場合（必要なら）"""
#    if p >= 0 and len(to[v]) == 1: 
#        return 1

    res = 1
    for i, child in enumerate(to[v]):
        if child == p:
            parent_index[child] = i
            continue
        """子供から情報をもらって処理する"""
        dp[v][i] = dfs(child, v)
        res *= 1+dp[v][i]
        res %= MOD
        """処理ここまで"""
    return res

def bfs(v, res_p, p):
    deg = len(to[v])
    if p >= 0:
        dp[v][parent_index[v]] = res_p

    dpl = [1]*(deg+1)
    for i in range(deg):
        dpl[i+1] = dpl[i]*(dp[v][i]+1)%MOD

    dpr = [1]*(deg+1)
    for i in range(deg-1,-1,-1):
        dpr[i] = dpr[i+1]*(dp[v][i]+1)%MOD

    ans[v] = dpr[0]
    
    for child in to[v]:
        if child == p: continue
        bfs(child, dpl[i]*dpr[i+1]%MOD, v)

dfs(0,-1)
#print(dp)
bfs(0,None,-1)
#print(dp)
for i in ans:
    print(i)

### FIXED CODE ###

# coding: utf-8
# Your code here!
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)

n,MOD = [int(i) for i in input().split()]

to = [[] for _ in [0]*n]
for _ in range(n-1):
    x,y = [int(i)-1 for i in input().split()]
    to[x].append(y)
    to[y].append(x)


dp = [[0]*len(to_i) for to_i in to]
parent_index = [-9999]*n 
ans = [0]*n

def dfs(v, p):
    res = 1
    for i, vc in enumerate(to[v]):
        if vc == p:
            parent_index[v] = i
            continue
        dp[v][i] = dfs(vc, v)
        res *= dp[v][i]+1
        res %= MOD
    return res

def dfs2(v, res_p, p):
    deg = len(to[v])
    if p >= 0:
        dp[v][parent_index[v]] = res_p

    accl = [1]*(deg+1)
    accr = [1]*(deg+1)

    for i in range(1, deg+1):
        accl[i] = accl[i-1] * (dp[v][i-1] + 1) % MOD
        accr[-i-1] = accr[-i] * (dp[v][-i] + 1) % MOD

    ans[v] = accr[0]
    for i,vc in enumerate(to[v]):
        if vc == p: continue
        dfs2(vc, accl[i]*accr[i+1]%MOD, v)

dfs(0,-1)
#print(dp)
dfs2(0,0,-1)
#print(dp)
for i in ans:
    print(i)