Harryxun/stf_run huggingface dataset:
a = int(input())
s = input()
if a >= 3200:
  print(S)
else:
  print('red')

### FIXED CODE ###

a = int(input())
s = input()
if a >= 3200:
  print(s)
else:
  print('red')
a,b=input().split()
c=input().split()
ct=0
for i in c:
  if i>=b: ct+=1
print(ct)

### FIXED CODE ###

a=int(input())
if a%2==0:
  print(1/2)
else:
  print((a//2+1)/a)
a,b,c=map(int,input().split())
if b!=0:
    k=a//(b+c)
    h=k*b
    t=a-b*k-c*k
    print(t+h)
else:
    print(0)

### FIXED CODE ###

a,b,c=input()
if a==b==c:
    print("No")
else:
    print("Yes")
r,g,b=map(int,input().split())
k = ((10*g) + b)%4
if k == 0 :print('YES')
  else:print('NO')

### FIXED CODE ###

r,g,b=input().split()
gb=g+b #str
if int(gb)%4 ==0:print('YES')
else:print('NO')
n = int(input())
d1d2 = [map(int, input().split()) for _ in range(n)]
d1, d2 = [list(i) for i in zip(*d1d2)]
count = 0
for i in range(n):
    if d1[i] == d2[i] and d1[i+1] == d2[i+1] and d1[i+2] == d2[i+2]:
        count += 1
if count > 0:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

n = int(input())
d1d2 = [map(int, input().split()) for _ in range(n)]
d1, d2 = [list(i) for i in zip(*d1d2)]
count = 0
for i in range(n-2):
    if d1[i] == d2[i] and d1[i+1] == d2[i+1] and d1[i+2] == d2[i+2]:
        count += 1
if count > 0:
    print("Yes")
else:
    print("No")
import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")

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

ans = -float('inf')
for i in range(n):
    now = i
    c_sum = [0]
    s = set()
    cnt = 0
    while True:
        s.add(now)
        c_sum.append(c_sum[-1] + c[now])
        cnt += 1
        now = p[now]
        if now in s:
            break
    if k < cnt:
        ans = max(ans, max(c_sum[1: k + 1]))
    else:
        score = c_sum[-1]
        count = k // cnt
        k_ = k - count*cnt
        score *= count
        score += max(c_sum[1: k_ + 1])
        ans = max(ans, score, max(c_sum[1: ]))
print(ans)




    

### FIXED CODE ###

import sys
input = lambda: sys.stdin.readline().rstrip("\r\n")

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

ans = -float('inf')
for i in range(n):
    now = i
    c_sum = [0]
    s = set()
    cnt = 0
    while True:
        s.add(now)
        c_sum.append(c_sum[-1] + c[now])
        cnt += 1
        now = p[now]
        if now in s:
            break
    c_sum = c_sum[1:]
    if k < cnt:
        ans = max(ans, max(c_sum[: k]))
    else:
        score = c_sum[-1]
        count = k // cnt
        k_ = k - count*cnt
        score *= count
        score_2 = score - c_sum[-1]
        score_2 += max(c_sum)
        if k_ > 0:
            score += max(0, max(c_sum[:k_]))
        ans = max(ans, score, max(c_sum), score_2)
print(ans)
n=input()
k=input()
a = [int(input()) for i in range(int(n))]
a.sort()
print(sum(a[:int(k)]))

### FIXED CODE ###

n,k = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
print(sum(a[:k]))
n=int(input())
ans=[]

nr=int(n**0.5)


for i in range(1,nr):
    if n%i==0:
        ans.append(i+n//i)
   
ans2=sorted(ans)
print(ans2[0]-2)

### FIXED CODE ###

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

nr=int(n**0.5)


for i in range(1,nr+1):
    if n%i==0:
        ans.append(i+n//i)
   
ans2=sorted(ans)
print(ans2[0]-2)
from math import math.pi as pi
r = int(input())
S = pi * r * r
R = 2 * pi * r
print("{0} {1}".format(S, R))

### FIXED CODE ###

from math import pi
r = float(input())
S = pi * r * r
R = 2 * pi * r
print("{0} {1}".format(S, R))
n,m = map(int,input().split())
x = list(map(int,input().split()))
x.sort()
if m == 1:
  print(0)
  exit()

if n%2 == 0:
  cutl = n//2 - 1
  cutr = len(x)+1-(n//2)
else:
  cutl = (n//2)
  cutr = len(x)-1+(n//2)

lis = x[cutl:cutr]
l = []

for i in range(len(lis)-1):
  l.append(abs(lis[i] - lis[i+1]))

print(lis[-1] - lis[0] -max(l))

### FIXED CODE ###

n,m = map(int,input().split())
x = list(map(int,input().split()))
x.sort()
if m <= n:
  print(0)
  exit()

l = []

for i in range(len(x)-1):
  l.append(x[i+1] - x[i])
  
l.sort(reverse = True)

for i in range(n-1):
  l[i] = 0
  
print(sum(l))
from collections import deque
 
N = int(input())
G = [deque([]) for _ in range(N)]
arrive = [0] *N
key = []
for _ in range(N-1):
    a,b = map(int,input().split())
    key.append((a,b))
    G[a-1].append(b-1)
    G[b-1].append(a-1)
 
MAX = 0
for i,g in enumerate(G):
    if MAX < len(g):
        MAX = len(g)
        t = i
 
c_l = list(range(MAX))
C = dict()
 
def bfs(v,c):
    arrive[v] = 1
    cnt = 0
    for w in G[v]:
        if arrive[w] == 0:
            if c == cnt:
                cnt += 1
            bfs(w,cnt)
            if v > w:
                v,w = w,v
            C[(v+1,w+1)] = cnt+1
            cnt += 1
 
bfs(1,-1)
 
print(MAX)
# print(C)
for k in sorted(key):
    print(C[k])

### FIXED CODE ###

from collections import defaultdict,deque

graph = defaultdict(list)
N, *AB = map(int, open(0).read().split())
for a, b in zip(*[iter(AB)] * 2):
    graph[a].append(b)


stack = deque([1])
C = [0] * (N + 1)
while stack:
    v = stack.popleft()
    c = 0
    for w in graph[v]:
        c += 1 + (c + 1 == C[v])
        C[w] = c
        stack.append(w)
        
print(max(C))
print("\n".join(str(C[b]) for b in AB[1::2]))
x = []

for i in range(n):
    x.append(int(v[i]-c[i]))

x.sort()

y = 0

i = n-1

while x[i] >= 0 and i >= 0 :
    y += x[i]
    i += -1

print(y)

### FIXED CODE ###

n = int(input())
v = [int(i) for i in input().split()]
c = [int(j) for j in input().split()]

x = []
 
for i in range(n):
    x.append(int(v[i]-c[i]))
 
x.sort()
 
y = 0
 
i = n-1
 
while x[i] >= 0 and i >= 0 :
    y += x[i]
    i += -1
 
print(y)
from fractions import gcd
P = 10**9 + 7
N = 1000001 #使う最大値+1以上にする、値に注意3*10^5とかにしとくと安心
inv = [0] + [1] # 1/x
finv = [1] + [1] # 1/x!
fac = [1] + [1] # x!
for i in range(2,N):
  inv += [inv[P % i] * (P - int(P / i)) % P]
  fac += [(fac[i-1] * i) % P]
  finv += [(finv[i-1] * inv[i]) % P]
n=int(input())
a=list(map(int,input().split()))
lcm=a[0]
mod=10**9+7
for i in range(1,n):
  lcm=(lcm//gcd(lcm,a[i]))*(a[i]//gcd(lcm,a[i]))*gcd(lcm,a[i])
ans=0
for i in range(n):
  ans+=lcm*inv[a[i]]%mod
print(ans%mod)

### FIXED CODE ###

n,m=map(int,input().split())
if n==m:
  print('Yes')
else:
  print('No')
N = int(input())
n_list = [int(i), for i in input().split("")]
ans = 0

while True:
  if [int(i) for n_list if i % 2 == 1]:
    break
  n_list = [i // 2 for i in n_list]
  ans += 1
print(ans)

### FIXED CODE ###

n = int(input())
nums = [int(i) for i in input().split()]
ans = 0
while True:
    if [i for i in nums if i % 2 == 1]:
        break
    nums = [i//2 for i in nums]
    ans += 1
print(ans)
n=int(input())
m=list(map(int,input().split()))
x=1
if 0 in m:
  print(0)
else:
  for y in m:
    x*=y
    if x>10**18:
      print(-1)
      break
	else:
      print(x)

### FIXED CODE ###

# coding: utf-8

n = int(input())
numlist = list(map(int, input().split()))
ans = 1;

if 0 in numlist:
    ans = 0
else:
    for i in numlist:
        ans *= i
        if ans > 10**18:
            ans = -1
            break

print(ans)
input()
num = list(map(int, input().split()))

i = 0
while all(num % 2 == 0):
  num // 2
  i += 1
  
print(i)


### FIXED CODE ###

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

count = 0
while all(n % 2 == 0 for n in Nums):
  Nums = [n/2 for n in Nums]
  count += 1

print(count)
N = int(input())
A = [int(x) for x in input().split()]

# Common divisor
def gcd(x, y):
    if y == 0:
        return x
    else:
        return gcd(y, x % y)


def gcd_wrapper(x, y):
    if x >= y:
        return gcd(x, y)
    else:
        return gcd(y, x)

if N == 2:
    print(max(A))
    exit()
if N == 3:
    x1 = gcd_wrapper(A[0], A[1])
    x2 = gcd_wrapper(A[1], A[2])
    x3 = gcd_wrapper(A[0], A[2])
    print(max([x1, x2, x3]))
    exit()

init_results = []
for k, g in enumerate(A[0:3]):
    for h in A[k+1:4]:
        init_results.append(gcd_wrapper(g, h))
if max(init_results) == 1:
    print(1)
    exit()
stop_flag = 0
x = max(init_results)
final_result = set()
final_result.add(x)
for i in A:
    tmp = gcd_wrapper(x, i)
    if tmp == 1:
        stop_flag += 1
    else:
        x = tmp
        final_result.add(tmp)
if stop_flag >= 2:
    print(1)
else:
    sorted_final_result = sorted(list(final_result))
    divable = []
    for j in A:
        if j % sorted_final_result[1] != 0:
            divable.append(1)
    if sum(divable) > 1:
        print(sorted_final_result[0])
    else:
        print(sorted_final_result[1])



### FIXED CODE ###

N = int(input())
A = [int(x) for x in input().split()]

# Common divisor
def gcd(x, y):
    if y == 0:
        return x
    else:
        return gcd(y, x % y)


def gcd_wrapper(x, y):
    if x >= y:
        return gcd(x, y)
    else:
        return gcd(y, x)

if N == 2:
    print(max(A))
    exit()
if N == 3:
    x1 = gcd_wrapper(A[0], A[1])
    x2 = gcd_wrapper(A[1], A[2])
    x3 = gcd_wrapper(A[0], A[2])
    print(max([x1, x2, x3]))
    exit()
A = sorted(A)
A.reverse()
init_results = []
for k, g in enumerate(A[0:3]):
    for h in A[k+1:4]:
        init_results.append(gcd_wrapper(g, h))
if max(init_results) == 1:
    print(1)
    exit()
stop_flag = 0
x = max(init_results)
final_result = set()
final_result.add(x)
for i in A:
    tmp = gcd_wrapper(x, i)
    if tmp == 1:
        stop_flag += 1
    else:
        x = tmp
        final_result.add(tmp)
if stop_flag >= 2:
    print(1)
else:
    sorted_final_result = sorted(list(final_result))
    if len(sorted_final_result) == 1:
        print(sorted_final_result[0])
        exit()
    divable = []
    for j in A:
        if j % sorted_final_result[1] != 0:
            divable.append(1)
    if sum(divable) > 1:
        print(sorted_final_result[0])
    else:
        print(sorted_final_result[1])
class edge():
    def __init__(self,_to,_cost):
        self.to = _to;
        self.cost = _cost;

N = int(input())
tree = [[] for i in range(N)]

for i in range(N-1):
    a,b,c = list(map(int, input().split()))
    a = a - 1
    b = b - 1
    tree[a].append(edge(b,c))
    tree[b].append(edge(a,c))
Q, K = list(map(int, input().split()))
K = K - 1

depth = [0]*N
def DFS(v,p,d):
    depth[v] = d
    for e in tree[v]:
        if e.to==p :
            continue
        DFS(e.to, v, d + e.cost)
DFS(K,-1,0)

for q in range(Q):
    x,y = list(map(int, input().split()))
    x = x - 1
    y = y - 1
    print(depth[x] + depth[y])


### FIXED CODE ###

import sys;sys.setrecursionlimit(int(1e7))

class edge():
    def __init__(self,_to,_cost):
        self.to = _to;
        self.cost = _cost;

N = int(input())
tree = [[] for i in range(N+1)]

for i in range(N-1):
    a,b,c = map(int,input().split())
    a = a - 1
    b = b - 1
    tree[a].append(edge(b,c))
    tree[b].append(edge(a,c))
Q,K = map(int,input().split())
K = K - 1
depth = [None]*N

def DFS(v,p,d):
    depth[v] = d
    for e in tree[v]:
        if e.to == p:
            continue
        DFS(e.to, v, d + e.cost)
DFS(K,-1,0)

for _ in range(Q):
    x,y = map(int, input().split())
    x = x - 1
    y = y - 1
    print(depth[x] + depth[y])
import sys
sys.setrecursionlimit(10**6)
if sys.platform in (['ios','darwin','win32']):
	sys.stdin=open('Untitled.txt')
input = sys.stdin.readline
def INT(): return int(input())
def MAP(): return [int(s) for s in input().split()]

#a,bの最大公約数
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

#a,bの最小公倍数
def lcm(a, b):
    return a * b // gcd (a, b)

def main():
	N, M = MAP()
	S = input().rstrip()
	T = input().rstrip()

	L = lcm(N, M)
	n = int(L//N)
	m = int(L//M)
	X = ['0']*L
	for i in range(0, L, n):
		X[i] = S[i//n]
	for i in range(0, L, m):
		if X[i] != '0' and X[i] != T[i//m]:
			print(-1)
			sys.exit()
	print(L)

if __name__ == '__main__':
	main()

### FIXED CODE ###

import sys
import fractions
sys.setrecursionlimit(10**6)
if sys.platform in (['ios','darwin','win32']):
	sys.stdin=open('Untitled.txt')
input = sys.stdin.readline
def INT(): return int(input())
def MAP(): return [int(s) for s in input().split()]

def main():
	N, M = MAP()
	S = input().rstrip()
	T = input().rstrip()

	L = (N*M)//fractions.gcd(N, M)
	# print(L)
	n = L//N
	m = L//M
	for i in range(0, L, n):
		if i % m == 0:
			if S[i//n] != T[i//m]:
				print(-1)
				sys.exit()
	print(L)


if __name__ == '__main__':
	main()
import math

s = int(input())

rot = int(math.sqrt(s) // 1)
if s == rot**2:
    print(f"0 0 0 {rot} 0 0 {rot}")
    exit()

rot += 1
ans = (rot**2) - s
print(f"0 0 {rot} 1 {ans} {rot}")


### FIXED CODE ###

import math

s = int(input())

rot = int(math.sqrt(s) // 1)
if s == rot**2:
    print("0 0 " + str(rot) + " 0 0 " + str(rot))
    exit()

rot += 1
ans = (rot**2) - s
print("0 0 " + str(rot) + " 1 " + str(ans) + " " + str(rot))
n = int(input())
pp = list(map(int, input().split()))
cnt = 0
for idx, p in enumerate(pp):
    if p == idx + 1:
        pp[idx], pp[idx+1] = pp[idx+1], pp[idx]
        cnt += 1
print(cnt)

### FIXED CODE ###

n = int(input())
pp = list(map(int, input().split()))
cnt = 0
for i in range(n-1):
    if pp[i] == i + 1:
        pp[i], pp[i+1] = pp[i+1], pp[i]
        cnt += 1
if pp[n-1] == n:
    cnt += 1
print(cnt)
def main():
    n, d = map(int, input().split())
    x = [int(input()) for i in range(n)]

    ans = 0
    for i in range(n-1):
        for j in range(i+1,n):
            res = 0
            for k in range(d):
                res += (j[k]-i[k])**2
            if (res**0.5).is_integer():
                ans += 1
    prnt(ans)

if __name__ == '__main__':
    main()



### FIXED CODE ###

def main():
    n, d = map(int, input().split())
    x = [list(map(int, input().split())) for i in range(n)]

    ans = 0
    for i in range(n-1):
        for j in range(i+1,n):
            res = 0
            for k in range(d):
                res += (x[j][k]-x[i][k])**2
            if (res**0.5).is_integer():
                ans += 1
    print(ans)

if __name__ == '__main__':
    main()
n,m = map(int,input().split())
alis = list(map(int,input().split()))
lis = [list(map(int,input().split())) for x in range(m)]
clis = [x[1]*x[0] for x in lis]
clis = [x for y in clis for x in y]
clis.sort(reverse=True)
alis.sort()
ans = 0
for x,y in zip(alis,clis):
    if x>=y:
        ans += x
    else:
        ans += y
print(p)
if len(clis) < len(alis):
    ans__ = sum(alis[len(clis):])
    ans += ans__
    print(ans)
else:
    print(ans)


### FIXED CODE ###

n,m = map(int,input().split())
alis = list(map(int,input().split()))
lis = [list(map(int,input().split())) for x in range(m)]
for x in alis:
    lis.append([1,x])
lis.sort(reverse=True,key=lambda x:x[1])
ans = 0
for x in lis:
    (number,point) = x
    if number >= n:
        number = n
        ans += number * point
        #print(n)
        #print(ans,'+=',number,'*',point)
        break
    ans += number * point
    n -= number
    #print(n)
    #print(ans,'+=',number,'*',point)
print(ans)
#print(lis)
22 3051

### FIXED CODE ###

import sys
from collections import deque, Counter, defaultdict
from fractions import gcd
input = lambda: sys.stdin.readline().rstrip()

def eprint(s):
    sys.stderr.write('DEBUG: {}'.format(s))
    return

def main():
    n, r = map(int, input().split())
    if n>= 10:
        print(r)
    else:
        # r = 100 * (10-n)
        print(r+ 100*(10-n))
    return

if __name__ == '__main__':
    main()
from itertools import accumulate
n,c = map(int,input().split())
wv = [[0,0]]+[list(map(int,input().split())) for i in range(n)]+[[c,0]]
n += 2
ansls = []
ls1 = [0]*n
ls2 = [0]*n
ls3 = [0]*n
ls4 = [0]*n
for i in range(1,n):
  w,v = wv[i]
  w -= wv[i-1][0]
  ls1[i] = v-w*2
  ls2[i] = v-w
for i in range(n-2,-1,-1):
  w,v = wv[i]
  w -= wv[i+1][0]
  ls3[n-i-1] = v+w*2
  ls4[n-i-1] = v+w
als1 = list(accumulate(ls1))
als2 = list(accumulate(ls2))
als3 = list(accumulate(ls3))
als4 = list(accumulate(ls4))
als1 = list(accumulate(als1,max))
als2 = list(accumulate(als2,max))
als3 = list(accumulate(als3,max))
als4 = list(accumulate(als4,max))
for i in range(n-1):
  ansls.append(als1[i]+als4[n-2-i])
  ansls.append(als2[i]+als3[n-2-i])
print(max(ansls))

### FIXED CODE ###

from itertools import accumulate
n,c = map(int,input().split())
wv = [[0,0]]+[list(map(int,input().split())) for i in range(n)]+[[c,0]]
n += 2
ansls = []
ls1 = [0]*n
ls2 = [0]*n
ls3 = [0]*n
ls4 = [0]*n
for i in range(1,n):
  w,v = wv[i]
  w -= wv[i-1][0]
  ls1[i] = v-w*2
  ls2[i] = v-w
for i in range(n-2,-1,-1):
  w,v = wv[i]
  w -= wv[i+1][0]
  ls3[n-i-1] = v+w*2
  ls4[n-i-1] = v+w
als1 = list(accumulate(ls1))
als2 = list(accumulate(ls2))
als3 = list(accumulate(ls3))
als4 = list(accumulate(ls4))
als1 = list(accumulate(als1,max))
als2 = list(accumulate(als2,max))
als3 = list(accumulate(als3,max))
als4 = list(accumulate(als4,max))
for i in range(n-1):
  ansls.append(als1[i]+als4[n-2-i])
  ansls.append(als2[i]+als3[n-2-i])
print(max(ansls))
n=int(input())
x=1000000000000000000
res=1
for i in range(n):
  res=res*int(input())
if(res>x):
  print("-1")
else:
  print(res)

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
res=1
if 0 in a:
  print("0")
else:
  for x in a:
    res=res*x
    if(res>1000000000000000000):
      res=-1
      break
  print(res)
import sys
def 解():
    input = sys.stdin.readline
    iN = int(input())
    aA = sorted([int(_) for _ in input().split()])
    aB = sorted([int(_) for _ in input().split()])
    aC = sorted([int(_) for _ in input().split()])

    #解法どおり書くとどれくらいでできるのか計測

    idxA = 0
    idxC = iN-1
    iAns = 0
    for idxB in range(iN):

        iB = aB[idxB]
        while idxA < iN and aA[idxA] < iB:
            idxA += 1
        idxA -= 1
        while 0 <= idxC  and aC[idxC] > iB:
            idxC -= 1
        idxC += 1
        if aA[idxA] >= iB or aC[idxC] <= iB:
            break
        else:
            iAns += (idxA + 1 )* (iN - idxC  )
    print(iAns)
解()


### FIXED CODE ###

import sys
def 解():
    input = sys.stdin.readline
    iN = int(input())
    aA = sorted([int(_) for _ in input().split()])
    aB = sorted([int(_) for _ in input().split()])
    aC = sorted([int(_) for _ in input().split()])

    aBA =[0]*iN
    iIndex = iN-1
    for i in range(iN-1,-1,-1):
        iB = aB[i]
        while aA[iIndex] >= iB:
            iIndex -= 1
            if iIndex < 0:
                break
        if iIndex >= 0 :
            aBA[i] = iIndex + 1
        else:
            break
    aAcBA=[0]*iN
    aAcBA[0]=aBA[0]
    for i in range(1,iN):
        aAcBA[i]=aAcBA[i-1]+aBA[i]
    iAns = 0
    iIndex = iN-1
    for i in range(iN-1,-1,-1):
        iC = aC[i]
        while aB[iIndex] >= iC:
            iIndex -= 1
            if iIndex < 0:
                break
        if iIndex >= 0 :
            iAns += aAcBA[iIndex]
        else:
            break
    print(iAns)
解()
import math
k = int(input())
a, b = [int(i) for i in input().split()]

if math.abs(a-b)+1 >= k:
    print("OK")
else:
    print("NG")

### FIXED CODE ###

k = int(input())
a, b = [int(i) for i in input().split()]

flg = False
for i in range(a, b+1):
  if i % k == 0:
    flg = True
    break
if flg:
  print("OK")
else:
  print("NG")
import itertools

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

if N==1:
    if A==B:
        print(1)
        exit()
    else:
        print(0)
        exit()


comb = list(itertools.combinations_with_replacement(range(A,B+1),N-2))

lis=[]
for x in comb:
    lis.append(sum(x))

lis = set(lis)
print(len(lis))

### FIXED CODE ###

import itertools

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

if N==1:
    if A==B:
        print(1)
        exit()
    else:
        print(0)
        exit()

if A > B:
    print(0)
    exit()

min = A*(N-1)+B
max = A+B*(N-1)

print(max-min+1)
N, A, B = map(int,input().split())
print(min(N*A, B)

### FIXED CODE ###

N, A, B = map(int,input().split())
print(min(N*A, B))
# coding: utf-8
s = raw_input();

k = u = p = c = 0;
for a in s:
    if a == 'K':
        k += 1;
    if a == 'U':
        u += 1;
    if a == 'P':
        p += 1;
    if a == 'C':
        c += 1;

print min(k,u,p,c);

### FIXED CODE ###

# coding: utf-8
s = raw_input();

k = u = p = c = 0;
for a in s:
    if a == 'K':
        k += 1;
    if a == 'U':
        u += 1;
    if a == 'P':
        p += 1;
    if a == 'C':
        c += 1;

print min(k,u,p,c);
N, Y = map(int, input().split())

for a in range(N):
    for b in range(N - a):
        c = N - a - b
        if 0 <= c <= 2000 & 10000 * a + 5000 * b + 1000 * c == Y:
            print(a,b,c)
            exit()

print(-1, -1, -1)

### FIXED CODE ###

N = int(input())
D = [input() for _ in range(N)]

print(len(set(D)))
n,l = list(map(int,input().split()))

flavor = int(n*(l+(l+n-1))/2)

if (l<0):
  if l>=(-n+1):
  	print(flavor)
  elif l<(-n+1):
    print(flavor-(l+n-1))
    

else:
  print(flavor-l)

### FIXED CODE ###

import sys
s = str(input())

k = None
for i in s:
  if i==k:
    print("Bad")
    sys.exit()
  k = i

print("Good")
N = int(input())

class UnionFind():
    def __init__(self, N):
        self.nodes = [i for i in range(N)]

    def root(self, x):
        if self.nodes[x] != x:
            self.nodes[x] = self.root(self.nodes[x])
        return self.nodes[x]

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

    def unite(self, x, y):
        if self.same(x, y):
            return
        self.nodes[self.root(x)] = self.root(y)

tree = UnionFind(N)
anti_list = []
for _ in range(N-1):
    u, v, w = map(int, input().split())
    if w % 2 == 0:
        tree.unite(u-1, v-1)
    else:
        anti_list.append((u-1, v-1))

while len(anti_list) > 1:
    base_u, base_v = anti_list[0]
    new_anti_list = [(base_u, base_v)]
    for anti_u, anti_v in anti_list[1:]:
        u_root = tree.root(anti_u)
        v_root = tree.root(anti_v)
        if u_root == base_u:
            tree.unite(base_v, v_root)
        elif u_root == base_v:
            tree.unite(base_u, v_root)
        elif v_root == base_u:
            tree.unite(base_v, u_root)
        elif v_root == base_v:
            tree.unite(base_u, u_root)
        else:
            new_anti_list.append((u_root, v_root))
    anti_list = new_anti_list

for i in range(N):
    print(1 if tree.same(0, i) else 0)


### FIXED CODE ###

N = int(input())

connections = [[] for _ in range(N)]

for _ in range(N-1):
    u, v, w = map(int, input().split())
    u -= 1
    v -= 1
    connections[u].append((v, w))
    connections[v].append((u, w))

COLOR_WHITE = 0
COLOR_BLACK = 1
COLOR_NONE = 2

colors = [COLOR_NONE for _ in range(N)]
colors[0] = COLOR_WHITE

stack = [(0, 0)]

while stack:
    root, abs_distance = stack.pop()
    for node, distance in connections[root]:
        if colors[node] == COLOR_NONE:
            new_distance = abs_distance+distance
            colors[node] = COLOR_WHITE if (new_distance) % 2 == 0 else COLOR_BLACK
            stack += [(node, new_distance)]

for c in colors:
    print(c)
A,B=map(int,input().split())
print(A*B if A<10 and B<10 else -1&)

### FIXED CODE ###

A,B=map(int,input().split())
print(A*B if A<10 and B<10 else -1)
n = int(input())
ans = [0 for _ in range(10000)]
for i in range(1, 101):
    for j in range(1, 101):
        for k in range(1, 101):
            v = i*i+j*j+k*k+i*j+j*k+k*i;
            if v < 10000:
                ans[v] += 1
for i in range(n):
    print(ans[i+1])


### FIXED CODE ###

n = int(input())
ans = [0 for _ in range(10050)]
for i in range(1, 105):
    for j in range(1, 105):
        for k in range(1, 105):
            v = i*i+j*j+k*k+i*j+j*k+k*i;
            if v < 10050:
                ans[v] += 1
for i in range(n):
    print(ans[i+1])