Harryxun/stf_run huggingface dataset:
N, P = map(int, input().split())
ans = 1
def main(n, p):
  global ans
  for i in range(2, int(p**(1/(n-1)))):
    if p % (i**n) == 0:
      ans *= i
      num = p // (i**n)
      return main(n, num)
  return ans

print(main(N, P))

### FIXED CODE ###

N, P = map(int, input().split())
ans = 1
def main(n, p):
  if n == 1:
    return P
  global ans
  for i in range(2, int(p**(2/n))):
    t = i**n
    if p % t == 0:
      ans *= i
      return main(n, p//t)
  return ans

print(main(N, P))
import sys

args = sys.argv

a = int(args[1])
b = int(args[2])
c = int(args[3])

zan = 0
if a >= b:
    zan = a - b
res = c - zan
if res <= 0:
    res = 0
print(res)


### FIXED CODE ###

A = [int(x) for x in input().split()]
a = A[0]
b = A[1]
c = A[2]
zan = 0
if a >= b:
  zan = a - b
res = c - zan
if res <= 0:
  res = 0
print(res)
tmp = ["Sunny", "Cloudy", "Rainy"]
today = input()

print(tmp[tmp.index(today)%3 + 1])

### FIXED CODE ###

tmp = ["Sunny", "Cloudy", "Rainy"]
today = input()

print(tmp[(tmp.index(today)+1)%3])
stairs = int(input())
stair_status = list(map(int,input().split(" ")))

count = []
for i in range(stairs-1):
    move = 1
    if stair_status[i+move]<stair_status[i+move]:
        count.append(move)
        break
    else:
        move += 1
    if (i + move +1)==stairs:
        count.append(move+1)
        break
    
    if count == []:
        pass
    else:
        if max(count)>=stairs-max(count):
            break

print(max(count))

### FIXED CODE ###

stairs = int(input())
stair_status = list(map(int,input().split(" ")))

move = 0
count = [0]
for i in range(stairs-1):
    if stair_status[i]>=stair_status[i+1]:
        move += 1
        count.append(move)
    else:
        count.append(move)
        move = 0  #reset
    
else:
    print(max(count))
N, Y = input().split()

for x in range(1, N):
    for y in range(1, N):
        if (N - x - y < 0) and (10000 * x + 5000 * y + 1000(N - x - y)) == Y:
            print(x, y, N - x - y)


### FIXED CODE ###

N, Y = map(int, input().split())
for x in range(N + 1):
    for y in range(N + 1):
        if (N - x - y >= 0) and (10000 * x + 5000 * y + 1000 * (N - x - y) == Y):
            print(x, y, N - x - y)
            break
    else:
        if x == N and y == N:
            print(-1, -1, -1)
        continue
    break
info = input().split(" ")
N = int(info[0])
A = int(info[1])
B = int(info[2])

if N*A =< B:
  print(N*A)
else:
  print(B)

### FIXED CODE ###

info = input().split(" ")
N = int(info[0])
A = int(info[1])
B = int(info[2])

if N*A <= B:
  print(N*A)
else:
  print(B)
n=int(input())
t=[]
for i in range(n):
    t.append(int(input()))

from fractions import gcd
lcm=1
for i in range(n):
    lcm=int((lcm*t[i])/gcd(lcm,t[i]))
print(lcm)


### FIXED CODE ###

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

from fractions import gcd
lcm=1
for i in range(n):
    lcm=(lcm*t[i])//gcd(lcm,t[i])
print(lcm)
import fractions
a,b = map(int,input().split())
print(a*b//gcd(a,b))

### FIXED CODE ###

import fractions
a,b = map(int,input().split())
print(a*b//fractions.gcd(a,b))
x, y = map(int, input().split())
if x > y:
    print('>')
else:
    print('<')

### FIXED CODE ###

x, y = input().split()
if x > y:
    print('>')
elif x == y:
    print('=')
else:
    print('<')
from math import factorial
X, Y = map(int,input().split())

MOD = 10**9+7


if (X+Y)%3 != 0:
    ans = 0
else:
    N = int((X+Y)/3)

    if X >= Y:
        #K = N - (X - Y) + 1
        K = N/2 - (X - Y) + 1

    else:
        K = N/2 + (Y - X) + 1

    #ans = factorial(N-1)/(factorial(N-K)*factorial(K-1))
    # ans = factorial(N+1-1)/(factorial(N-K+1)*factorial(K-1))
    # ans %= MOD
    bunsi = factorial(N)%MOD
    bunbo = (factorial(N-K+1)*factorial(K-1))%MOD
    ans = int(bunsi/bunbo)


#print(N)
#print(K)
print(ans)

### FIXED CODE ###

# nCr mod m
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
    n1, r = n+1, min(r, n-r)
    numer = denom = 1
    for i in range(1, r+1):
        numer = numer * (n1-i) % mod
        denom = denom * i % mod
    return numer * pow(denom, mod-2, mod) % mod

X, Y = map(int, input().split())
if (X+Y) % 3 != 0 or not (X <= 2*Y and Y <= 2*X):
    print(0)
    exit()

n = (X+Y) // 3
r = Y - n
#print(n, r)
print(combination(n, r))
import math

a, b = map(int, input().split())
gcd = math.gcd(a, b)
ans = int(a*b/gcd)
print(ans)

### FIXED CODE ###

def get_gcd(a, b):
    if a < b:
        a, b = b, a
    r = -1
    while r:
        r = a % b
        a = b
        b = r
    return a

a, b = map(int, input().split())
g = get_gcd(a, b)
ans = int(a * b / g)
print(ans)
import bisect
A.sort()
A = [-1] + A
for i in range(M):
    b, c = map(int, input().split())
    idx = bisect.bisect_left(A, c)
    #print(A[:idx], A[idx:])
    A = A[:idx] + [c] * b + A[idx:]
    A = A[-N:]
    #print(A)
print(sum(A))

### FIXED CODE ###


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

A.sort()

CB = []
for i in range(M):
    B, C = map(int, input().split())
    CB.append([C, B])
    
CB.sort(reverse=True)

idx = 0
c = 0
for i in range(N):
    if A[i] < CB[idx][0]:
        A[i] = CB[idx][0]
        c += 1
    if CB[idx][1] <= c:
        idx += 1
        c = 0
    if idx >= M:
        break
    #print(A)
        
print(sum(A))
a = {chr(i): 0 for i in range(97, 123)}
print(a)
while 1:
    s = input().lower()
    for c in s:
        if c in a:
            a[c] += 1
    for c in a:
        print("{} : {}".format(c, a[c]))

### FIXED CODE ###

import sys
cnts = {}
for line in sys.stdin:
    for c in list(line.lower()): cnts[c] = cnts.get(c,0) + 1
  
for c in range(ord('a'),ord('z')+1): print(chr(c),':',cnts.get(chr(c),0))
def sakujo():
 moji1 = raw_input()
 moji2 = raw_input()
  
 a, b = len(moji1), len(moji2)
 x1 = [0 for i in range(b+1)]
 for i in range(a):
  e1 = moji1[i]
  x2 = x1+[]
  for j in range(b):
   if e1 == moji2[j]:
    x1[j+1] = x2[j] + 1
   elif x1[j+1] < x1[j]:
    x1[j+1] = x1[j]
 return x1[-1]

 
n=input()
for ix in range(n):
 def sakujo

### FIXED CODE ###

def longest():
    alps1 = raw_input()
    alps2 = raw_input()
    
    x, y = len(alps1), len(alps2)
    k = [0 for i in range(y+1)]
    for i in range(x):
        e1 = alps1[i]
        l = k+[]
        for j in range(y):
            if e1 == alps2[j]:
                k[j+1] = l[j] + 1
            elif k[j+1] < k[j]:
                k[j+1] = k[j]
 
    return k[-1]
    
n = input()
for i in range(n):
    print longest()
#coding: utf-8
def isInOut(p, q, s, c, z):
    if (p*c[0] + q*c[1] - s)*(p*z[0] + q*z[1] - s) > 0:
        return True
    else:
        return False

while 1:
    try:
        x = [0 for i in xrange(3)]
        y = [0 for i in xrange(3)]
        c = [0 for i in xrange(2)]
        z = [0 for i in xrange(2)]
        a,b,t = [[0 for i in xrange(2)] for i in xrange(3)]
        p,q,s = [[0 for i in xrange(3)] for i in xrange(3)]
        x[0],y[0],x[1],y[1],x[2],y[2],z[0],z[1] = map(float, raw_input().split())
        c = [sum(x)/3, sum(y)/3]
            
        for j in xrange(3):
            if x[j] == x[j-1]:
                p[j] = 1.
                q[j] = 0.
                s[j] = x[j]
            else:
                t[j] = (y[j] - y[j-1]) / (x[j] - x[j-1])
                p[j] = t[j]
                q[j] = -1.
                s[j] = t[j]*x[j]-y[j]
            #print p[j], q[j], s[j]
            if isInOut(p[j], q[j], s[j], c, z) is False:
                print "NO"
                break
        else:
            print "YES"
            
    except EOFError:
        break

### FIXED CODE ###

def dot(a, b):
    return (a.real*b.real - a.imag*b.imag)
def cross(a, b):
    return (a.real*b.imag - a.imag*b.real)

EPS = 10**(-7)

def isIntersectedLS(a1, a2, b1, b2):
    return ((cross(a2-a1, b1-a1) * cross(a2-a1, b2-a1)) < EPS and
            (cross(b2-b1, a1-b1) * cross(b2-b1, a2-b1)) < EPS)

while 1:
    try:
        x,y = [[0. for i in xrange(3)] for j in xrange(2)]
        a = []
        z = [0. for i in xrange(2)]
        line = raw_input().split()
        if line == []: break
        x[0],y[0],x[1],y[1],x[2],y[2],z[0],z[1] = map(float, line)
        for i in xrange(3):
            a.append((x[i]+(y[i])*1j))
        c = (sum(x)/3)+(sum(y)/3)*1j
        p = z[0]+z[1]*1j
           
        for i in xrange(3):
            #print a, c, p
            if isIntersectedLS(a[i-1], a[i], c, p) is True:
                print "NO"
                break
        else:
            print "YES"
           
    except EOFError:
        break
S = input()
T = input()

count = 0
for i in range(len(S)):
	if S[i] != T[i]:
    	count += 1
print(count)

### FIXED CODE ###

S = input()
T = input()

counter = 0
for i in range(len(S)):
  if S[i] != T[i]:
    counter += 1

print(counter)
x,y = map(int,input().split())
a = []
n=int,input()
for i in range(n):
    b = list(map(int,input().split()))
    a.append(b[1:])
c = [i for i in range (1,m+1)]
for i in a:
    for j in range(m):
        if c[j] not in i:
            c[j]=0
print(m-c.count(0))

### FIXED CODE ###

x,y = map(int,input().split())
a = list(map(int,input().split()))
b = set(a[1:])
for i in range(x-1):
    a = list(map(int,input().split()))
    b = b & set(a[1:])
print(len(b))
w, a, b = map(int, input().split())
if abs(a-b) <= w:
    print(0)
else:
    print(min(abs(b-a-w), abs(a-b-w))

### FIXED CODE ###

w, a, b = map(int, input().split())
if abs(a-b) <= w:
    print(0)
else:
    print(min(abs(b-a-w), abs(a-b-w)))
N, A, B = input().split()
q, mod = divmod(N, A+B)

if mod > A:
  print((q+1)*A)
else :
  print(q*A+mod)

### FIXED CODE ###

N, A, B = map(int, input().split())
q, mod = divmod(N, A+B)
if mod >= A:
	print(q*A+A)
else: 
	print(q*A+mod)
N = int(input())
li = list(map(int,input().split()))
out_count = 0
if li[0] > li[1] + 1:
  out_count += 1

for j in range(N - 1 , 0 , -1):
  if li[j] >= li[j - 1] + 2:
    out_count += 1
  elif li[j] == li[j - 1] + 1:
    li[j - 1] -= 1


if out_count == 0:
  print('Yes')
else:
  print('No')

### FIXED CODE ###

N = int(input())
li = list(map(int,input().split()))
out_count = 0

for j in range(N - 1 , 0 , -1):
  if li[j] <= li[j - 1] - 2:
    out_count += 1
  elif li[j] == li[j - 1] - 1:
    li[j - 1] -= 1
if out_count == 0:
  print('Yes')
else:
  print('No')
N=int(input())
h=list(map(int,input().split()))
t=[0]*N
a=0
for i in range(N):
        while t[i]<h[i]:
                for j in range(i,N):
                        if t[j]<h[j]:
                                t[j]+=1
                        else:
                                break
                a+=1
print(a)

### FIXED CODE ###

a,b,c=map(int,input().split())
print(a*b//2)
from collections import Counter
    
n = int(input())
v = list(map(int, input().split()))
odd = v[::2]
even = v[1::2]
    
c_even = Counter(even).most_common(2)
c_odd = Counter(odd).most_common(2)

# print(c_even, c_odd)
    
if(c_even[0][0] != c_odd[0][0]):
    print(n - c_even[0][1] - c_odd[0][1])
elif(len(c_even) >= 2):
    second = max[c_even[1][1], c_odd[1][1]]
    print(n - c_even[0][1] - second)
else:
    print(n//2)

### FIXED CODE ###

from collections import Counter
    
n = int(input())
v = list(map(int, input().split()))
odd = v[::2]
even = v[1::2]
    
c_even = Counter(even).most_common(2)
c_odd = Counter(odd).most_common(2)

    
if(c_even[0][0] != c_odd[0][0]):
    print(n - c_even[0][1] - c_odd[0][1])
else:
    if(len(c_even) == 1):
        print(n//2)
    else:
        # second = max[c_even[1][1], c_odd[1][1]]
        # print(n - c_even[0][1] - second)
        print(n - max(c_even[0][1] + c_odd[1][1], c_even[1][1] + c_odd[0][1]))
s = input()
t = input()
passlist = []
for i in reversed(range(1,len(s)-len(t)+2)):
	u = s[i-1:i+len(t)-1]
	flag = True
	for i in range(len(u)):
		if(u[i] != '?' and u[i] != t[i]):
			flag = False
	if flag:
		text = (s[:i-2] + t + s[-1+len(t)-1+i:]).replace('?','a')
		passlist.append(text)

passlist.sort()
print(passlist[0])



### FIXED CODE ###

from copy import deepcopy
from sys import exit,setrecursionlimit
import math
from collections import defaultdict,Counter,deque
from fractions import Fraction as frac
import fractions
from functools import reduce
import bisect
import sys
import logging
import heapq

#logging.basicConfig(level=logging.DEBUG)

input = sys.stdin.readline

setrecursionlimit(1000000)


def main():
	s = input()[:-1]
	t = input()[:-1]
	for i in reversed(range(len(s) - len(t) + 1)):
		flag = True
		for j in range(len(t)):
			if(s[i+j]  != '?' and s[i+j] != t[j]):
				flag = False
				break
		if flag:
			ans = []
			for j in s:
				ans.append(j)
			for j in range(i, i+len(t)):
				ans[j] = t[j-i]
			a = ''
			for i in ans:
				a += i
			print(a.replace('?','a'))
			return
	print('UNRESTORABLE')


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 zip(a):
	mae = a[0]
	ziparray = [mae]
	for i in range(1,len(a)):
		if(mae != a[i]):
			ziparray.append(a[i])
			mae = a[i]
	return ziparray

def is_prime(n):
	if n < 2: return False

	for k in range(2, int(math.sqrt(n)) + 1):
		if n % k == 0:
			return False

	return True

def list_replace(n,f,t):
	return [t if i==f else i for i in n]

def base_10_to_n(X, n):
	X_dumy = X
	out = ''
	while X_dumy>0:
		out = str(X_dumy%n)+out
		X_dumy = int(X_dumy/n)
	if(out == ''): return '0'
	return out

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

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

class Queue():
	def __init__(self):
		self.q = deque([])
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.popleft()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class Stack():
	def __init__(self):
		self.q = []
	def push(self,i):
		self.q.append(i)
	def pop(self):
		return self.q.pop()
	def size(self):
		return len(self.q)
	def debug(self):
		return self.q

class graph():
	def __init__(self):
		self.graph = defaultdict(list)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
		self.graph[t].append(f)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
		self.graph[t].remove(f)
	def linked(self,f):
		return self.graph[f]

class dgraph():
	def __init__(self):
		self.graph = defaultdict(set)
	def addnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].append(t)
	def rmnode(self,l):
		f,t = l[0],l[1]
		self.graph[f].remove(t)
	def linked(self,f):
		return self.graph[f]

class PriorityQueue():
	def __init__(self):
		self.queue = []
	def push(self,i):
		heapq.heappush(self.queue,-i)
	def pop(self):
		return -1 * heapq.heappop(self.queue)
	def sum(self):
		return -sum(self.queue)

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

m = 0
for i in s:
    mae = len(s)
    s = [j for j in s if j != i]
    ato = len(s)
    num = mae - ato

    if num > m:
        ans = [i]
        m = num
    elif num == m:
        ans.append(i)


ans.sort()

#print(*ans,sep='\n')
print('\n'.join(map(str, ans)))
#for i in range(len(ans)):
#    print(ans[i])

        


### FIXED CODE ###

import collections

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

c = collections.Counter(s)
common = c.most_common()

count = common[0][1]
ans = []
for i in common:
  if i[1] == count:
    ans.append(i[0])
  else:
    break
ans.sort()
print(*ans,sep='\n')
i = 0

while 1:
  x = raw_input()
  i += 1
  if x == "0":
    break
  print "Case %d: %d" % i,x

### FIXED CODE ###

i = 0

while 1:
  x = raw_input()
  i += 1
  if x == "0":
    break
  print "Case %d: %s" % (i,x)
#!python3

import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
from heapq import heappush, heappushpop

def resolve():
    it = map(int, sys.stdin.read().split())

    T = next(it)
    if T == 3: raise 1
    ans = []
    for i in range(T):
        N = next(it)

        val = 0
        a1 = [[] for i in range(N)]
        a2 = [[] for i in range(N)]
        #for i, v1, v2 in ((next(it)-1, next(it), next(it)) for i in range(N)):
        for _, i, v1, v2 in zip(range(N), it, it, it):
            diff = v1 - v2
            if diff == 0 or i == N-1:
                val += v1
            elif diff > 0:
                a1[i].append(diff)
                val += v2
            else:
                i = N-1-i-1
                a2[i].append(-diff)
                val += v1

        for ax in (a1, a2):
            dq = []
            for i, aa in enumerate(ax):
                if not aa: continue
                for diff in aa:
                    ld = len(dq)
                    if ld <= i:
                        heappush(dq, diff)
                        val += diff
                    else:
                        df = heappushpop(dq, diff)
                        val += diff - df

        ans.append(val)


    print(*ans, sep="\n")



if __name__ == "__main__":
    resolve()


### FIXED CODE ###

#!python3

import sys
iim = lambda: map(int, sys.stdin.readline().rstrip().split())
sys.setrecursionlimit(1000000000)

def resolve():
    it = map(int, sys.stdin.read().split())

    T = next(it)
    ans = []
    for i in range(T):
        N = next(it)

        val = 0; a1 = []; a2 = []
        for i, v1, v2 in ((next(it), next(it), next(it)) for i in range(N)):
            diff = v1 - v2
            a, v, diff = (a1, v2, diff) if diff >= 0 else (a2, v1, -diff)
            a.append((diff, i))
            val += v
        a1.sort(reverse=True); a2.sort(reverse=True)

        ls = len(a1)
        vis = [None]*(N+1)
        def root(x):
            if vis[x] == None: return x

            vis[x] = root(vis[x])
            return vis[x]
        def root(x):
            a = []
            while True:
                y = vis[x]
                if y == None:
                    break
                a.append(x)
                x = y
            for i in a:
                vis[i] = x
            return x

        for diff, i in a1:
            j = min(i, ls) - 1
            k = root(j)
            #print(diff, i, j, k,  vis)
            if k < 0: continue
            val += diff
            vis[k] = k - 1


        for diff, i in a2:
            j, v2 = max(i, ls), [[-1]]
            k = root(j)
            #print(diff, i, j, k,  vis)
            if k >= N: continue
            val += diff
            vis[k] = k + 1

        ans.append(val)

    print(*ans, sep="\n")



if __name__ == "__main__":
    resolve()
s=input()
n=len(s)
if s[0]==s[(n-3)/2] and s[(n+1)/2]==s[n-1]:
  print ('Yes')
else:
  print('No')

### FIXED CODE ###

s=input()
ans='No'
if s==s[::-1]:
  t=s[:len(s)//2]
  if t==t[::-1]:
    u=s[len(s)//2+1:]
    if u==u[::-1]:
      ans='Yes'
print(ans)
import collections

n = int(input())
L = [int(input()) for i in range(n)]
L.sort()
c = collections.Counter(L)
ccc = c.values()
ans = 0
for j in range(len(ccc)):
  if ccc[j] % 2 = 1:
    ans += 1
    

### FIXED CODE ###

n = int(input())
A = [input() for _ in range(n)]

import collections
C = collections.Counter(A)
ans = 0
for a in C.values():
    if a % 2 == 1:
        ans += 1

print(ans)
A,B,T = map(input().split())
print(T//A*B)


### FIXED CODE ###

A,B,T = map(int,input().split())
print(T//A*B)
n,k=map(int,input().split())
s=input()
if s[k+1]=="A":
    s[k+1]="a"
elif s[k+1]=="B":
    s[k+1]="b"
elif s[k+1]=="C":
    s[k+1]="c"
print(s)


### FIXED CODE ###

n,k=map(int,input().split())
s=list(input())
if s[k-1]=="A":
    s[k-1]="a"
elif s[k-1]=="B":
    s[k-1]="b"
elif s[k-1]=="C":
    s[k-1]="c"
print("".join(s))
import sys
from functools import lru_cache
sys.setrecursionlimit(100001)

N, M = map(int, input().split())
b = tuple([int(input()) for i in range(M)])

mod = 10**9+7

@lru_cache(maxsize=None)
def Fib(n, a):
    if n == 1:
        return 0
    elif n == 2:
        return 1
    elif (n-2 in a) and n!=0:
        return 0
    else:
        return (Fib(n-1, a) + Fib(n-2, a)) % mod

print(Fib(N+2, b))

### FIXED CODE ###

N, M = map(int, input().split())
#A = [int(input()) for i in range(M)]
flag = [0]*N
for i in range(M):
    flag[int(input())-1] = 1
#A = [i*3 for i in range(N//3)]
#for i in range(N//3):
    #flag[i] = 1

mod = 10**9+7

dp = [0] * N

if flag[0]==0:
#if 1 not in A:
    dp[0] = 1
    if N>1:
        if flag[1]==0:
    #if (2 not in A) and N > 1:
            dp[1] = 2
elif N > 1:
    if flag[1]==0:
    #if 2 not in A:
        dp[1] = 1
    else:
        dp[1] = 0

loop = []
'''
for i in range(2, N):
    if i not in A:
        loop.append(i)
'''
for i in range(2, N):
    if flag[i]==0:
        dp[i] = (dp[i-2] + dp[i-1]) % mod
        #dp[i] = (sum(dp[i-2:i])) % mod

print(dp[N-1])
#print(dp)
N,K = map(int, input().split(' '))
x = N % K
x1 = K - x
if x > x1:
  print(x1)
else:
  print(x)

### FIXED CODE ###

X, Y, Z = map(int, input().split(' '))
print(Z,X,Y)
N = int(input())
A = int(input())
B = int(input())
if N == 1:
    print("Hello World")
else:
    print(A + B)

### FIXED CODE ###

if int(input()) == 1:
    print("Hello World")
else:
    print(int(input()) + int(input()))
i=0

while c != 0:
    c = int(input())
    i = i+1
    print "Case %d: %d" %  (i,a)

### FIXED CODE ###

i=0

while True:
    a = int(input())
    if(a==0):
      break
    i = i+1
    print "Case %d: %d" %  (i,a)
n = int(input())
t,a = map(int,input().split())
H_list = list(map(int,input().split()))
temp_list = [t-h*0.006 for h in H_list ]
ans_list = [abs(a-x) for x in temp_list]
ans = min(ans_list)
print(ans_list.index(ans)+1)   

### FIXED CODE ###

x,y = map(int,input().split())
print(x + y // 2)
a, b, c = map(int, input().split())
five = 0;
if a == 5:
  five = five + 1;
elif a == 7:
  seven = seven + 1;
if b == 5:
  five = five + 1;
elif b == 7:
  seven = seven + 1;
if c == 5:
  five = five + 1;
elif c == 7:
  seven = seven + 1;
if five == 2 and seven == 1:
  print("YES")
else:
  print("NO")

### FIXED CODE ###

a, b, c = map(int, input().split())
five = 0
seven =0
if a == 5:
  five = five + 1;
elif a == 7:
  seven = seven + 1;
if b == 5:
  five = five + 1;
elif b == 7:
  seven = seven + 1;
if c == 5:
  five = five + 1;
elif c == 7:
  seven = seven + 1;
if five == 2 and seven == 1:
  print("YES")
else:
  print("NO")
h = int(input())
mount = [int(_) for _ in input().split()]
count = 0
for i in range(h):
  if i == 0
    count += 1
  else:
    for j in range(i):
      if mount[i]<mount[j]:
        break
    else:
      count += 1
print (count)

### FIXED CODE ###

h = int(input())
mount = [int(_) for _ in input().split()]
count = 0
for i in range(h):
  if i == 0:
    count += 1
  else:
    for j in range(i):
      if mount[i]<mount[j]:
        break
    else:
      count += 1
print (count)
n,m=map(int,input().split())
print(2**m*(100n+1800m))

### FIXED CODE ###

n,m=map(int,input().split())
print((2**m)*(100*n+1800*m))
#!/usr/bin/env python3
#ABC132 D
import sys
sys.setrecursionlimit(1000000)
from collections import deque

inf = 10**9+7
N,K = map(int,input().split())

fact = [1]*10000
for i in range(1,10000):
    fact[i] = fact[i-1]*i

for i in range(1,K+1):
    if N - K + 1 < i:
        print(0)
    else:
        ans = (fact[N-K+1]/(fact[i]*fact[N-K-i+1])) % inf
        ans *= (fact[K-1]/(fact[i-1]*fact[K-i])) % inf
        print(int(ans))


### FIXED CODE ###

#!/usr/bin/env python3
#ABC132 D
import sys
sys.setrecursionlimit(1000000)
from collections import deque

inf = 10**9+7
N,K = map(int,input().split())

fact = [1]*10000
for i in range(1,10000):
    fact[i] = fact[i-1]*i

for i in range(1,K+1):
    if N - K + 1 < i:
        print(0)
    else:
        ans = (fact[N-K+1]//fact[i]//fact[N-K-i+1])
        ans *= (fact[K-1]//fact[i-1]//fact[K-i])
        print(ans%inf)