Harryxun/stf_run huggingface dataset:
# coding: UTF-8
import sys
#sys.setrecursionlimit(n)
import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

n = readi()
d = []
for i in range(n):
    k = readi()
    d.append(k)
p = []
g = -1
for i in range(n - 1):
    t = d[i]
    k = max(d[i+1:n])
    print(max(k, g))
    g = max(t, g)
print(max(d[0],g))

### FIXED CODE ###

# coding: UTF-8
import sys
#sys.setrecursionlimit(n)
import heapq
import re
import bisect
import random
import math
import itertools
from collections import defaultdict, deque
from copy import deepcopy
from decimal import *

readl= lambda: list(map(int, sys.stdin.readline().split()))
readt= lambda: tuple(map(int, sys.stdin.readline().split()))
read = lambda: sys.stdin.readline().rstrip()
readi = lambda: int(read())
readmi = lambda: map(int, sys.stdin.readline().split())
readms = lambda: map(str, sys.stdin.readline().split())

a = int(input())
print(3 * (a ** 2))
A=list(map(int, input().split()))
if N<=2:
    print(1)
    exit()

now=0
ans=1
for i in range(1,N):
    if i==1:
        if A[i]-A[i-1]==0:
            now=0
        else:
            now=(A[i]-A[i-1])//(abs(A[i]-A[i-1]))
        if now>=1:
            plus=True
        elif now==0:
            plus=-1
        else:
            plus=False
            
    else:
        if A[i]-A[i-1]==0:
            nex=0
        else:
            nex=(A[i]-A[i-1])//(abs(A[i]-A[i-1]))
        if plus==-1:
            if nex>=1:
                plus=True
            elif nex<0:
                plus=False
        elif plus:
            if nex<0:
                plus=-1
                ans+=1
        else:
            if nex>0:
                plus=-1
                ans+=1

print(ans)



### FIXED CODE ###

N=int(input())
A=list(map(int, input().split()))
if N<=2:
    print(1)
    exit()

now=0
ans=1
for i in range(1,N):
    if i==1:
        if A[i]-A[i-1]==0:
            now=0
        else:
            now=(A[i]-A[i-1])//(abs(A[i]-A[i-1]))
        if now>=1:
            plus=True
        elif now==0:
            plus=-1
        else:
            plus=False
            
    else:
        if A[i]-A[i-1]==0:
            nex=0
        else:
            nex=(A[i]-A[i-1])//(abs(A[i]-A[i-1]))
        if plus==-1:
            if nex>=1:
                plus=True
            elif nex<0:
                plus=False
        elif plus:
            if nex<0:
                plus=-1
                ans+=1
        else:
            if nex>0:
                plus=-1
                ans+=1

print(ans)
import itertools

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

MOD = 10**9 + 7
MAX_NUM = 10**5

def inv_mod(n):
  return pow(n, MOD-2, MOD)

FACTS = [1 for _ in range(MAX_NUM+1)]
for n in range(1, MAX_NUM+1):
  FACTS[n] = (n*FACTS[n-1]) % MOD

INV_FACTS = [1 for _ in range(MAX_NUM+1)]
INV_FACTS[MAX_NUM] = inv_mod(FACTS[MAX_NUM])
for n in range(MAX_NUM-1, -1, -1):
  INV_FACTS[n] = (INV_FACTS[n+1]*(n+1)) % MOD
  
for i in range(MAX_NUM+1):
  assert (FACTS[i]*INV_FACTS[i])%MOD == 1

def ncr(n, r):
  if r > n:
    return 0
  if r < 0:
    return 0
  # C(n, r) = n!/(n-r)!r!
  ans = FACTS[n]*INV_FACTS[n-r]*INV_FACTS[r]
  return ans % MOD

from collections import defaultdict
v2i = defaultdict(list)
for i, v in enumerate(A):
  v2i[v].append(i)

fst, snd = -1, -1
for v in v2i:
  if len(v2i[v]) == 2:
    fst, snd = v2i[v]

K = snd - fst - 1
for ell in range(1, N+2):
  ans = ncr(N+1, ell) - ncr(N-1-K, ell-1)
  print(ans%MOD)


### FIXED CODE ###

import itertools

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

MOD = 10**9 + 7
MAX_NUM = 10**5 + 10

def inv_mod(n):
  return pow(n, MOD-2, MOD)

FACTS = [1 for _ in range(MAX_NUM+1)]
for n in range(1, MAX_NUM+1):
  FACTS[n] = (n*FACTS[n-1]) % MOD

INV_FACTS = [1 for _ in range(MAX_NUM+1)]
INV_FACTS[MAX_NUM] = inv_mod(FACTS[MAX_NUM])
for n in range(MAX_NUM-1, -1, -1):
  INV_FACTS[n] = (INV_FACTS[n+1]*(n+1)) % MOD
  
for i in range(MAX_NUM+1):
  assert (FACTS[i]*INV_FACTS[i])%MOD == 1

def ncr(n, r):
  if r > n:
    return 0
  if r < 0:
    return 0
  # C(n, r) = n!/(n-r)!r!
  ans = FACTS[n]*INV_FACTS[n-r]*INV_FACTS[r]
  return ans % MOD

from collections import defaultdict
v2i = defaultdict(list)
for i, v in enumerate(A):
  v2i[v].append(i)

fst, snd = -1, -1
for v in v2i:
  if len(v2i[v]) == 2:
    fst, snd = v2i[v]

K = snd - fst - 1
for ell in range(1, N+2):
  ans = ncr(N+1, ell) - ncr(N-1-K, ell-1)
  print(ans%MOD)
N = int(input())
nd = [0] * (N+1)
for i in range(1, N):
    for j in range(i, N, i):
        nd[j] += 1
print(sum(nd))

### FIXED CODE ###

N = int(input())
nd = [0] * (N+1)
for i in range(1, N):
    for j in range(i, N, i):
        nd[j] += 1
print(sum(nd))
from collections import Counter
N = int(input())
S = [int(input()) for i in range(N)]

count = Counter(S)
maxnum = max(count.values())
maxlist= [i for i,j in count.items() if j==maxnum]

maxlist.sort()
print("/n".join(maxlist))

### FIXED CODE ###

from collections import Counter
N = int(input())
S = [input() for i in range(N)]

count = Counter(S)
maxnum = max(count.values())
maxlist= [i for i,j in count.items() if j==maxnum]

maxlist.sort()

for m in maxlist:
	print(m)
s=input()
k=int(input())

for i in range(len(s)):
    if s[i]!='1':
        t=i+1
        a=s[i]
        break
if k<t:
    print(s[k-1])
else:
    print(a)

### FIXED CODE ###

s=input()
k=int(input())
t=0
a=1
for i in range(len(s)):
    if s[i]!='1':
        t=i+1
        a=s[i]
        break
if k<t:
    print(s[k-1])
else:
    print(a)
#input
N, K = map(int, input().split())
A = list(map(int, input().split()))

#output
import numpy as np
import math
A = np.array(A)
A = np.sort(A)

def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result

x = np.full(N, 0, int)
for i in range(N-K+1):
    x[i] = cmb(N-i-1, N-K-i)

y = -x + x[-1::-1]

print((A*y).sum() % (10**9 + 7))

### FIXED CODE ###

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

#output
import math

A.sort()
mod = 10**9+7

n_ = 10**5 + 3
fun = [1]*(n_+1)
for i in range(1,n_+1):
    fun[i] = fun[i-1]*i%mod
rev = [1]*(n_+1)
rev[n_] = pow(fun[n_],mod-2,mod)
for i in range(n_-1,0,-1):
    rev[i] = rev[i+1]*(i+1)%mod
def cmb(n,r):
    if n <= 0 or r < 0 or r > n: return 0
    return fun[n]*rev[r]%mod*rev[n-r]%mod
#これだとTLE!
"""
def cmb(n, r):
    if n < r: return 0
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])

    return result
"""

M = 0
m = 0
for i, a in enumerate(A):
    M += cmb(i, K-1) * a
    m += cmb(N-i-1, K-1) * a
    M %= mod
    m %= mod

print((M-m) % mod)
def A_Sandglass2():
    try:
        LOCAL_FLAG
        X = 100
        t = 170
    except NameError:
        X, t = list(map(int, input().split()))

    R = X - t
    if R > 0:
        print(R)
    else:
        print("0")

start = time.time()
A_Sandglass2()
elapsed_time = time.time() - start
try:
    LOCAL_FLAG
    print ("elapsed_time: {0}".format(elapsed_time) + "[sec]")
except NameError:
    pass

### FIXED CODE ###

import numpy as np
import sys
import itertools
import time

# # A - Sandglass2
# #
# #
def A_Sandglass2():
    try:
        LOCAL_FLAG
        X = 100
        t = 170
    except NameError:
        X, t = list(map(int, input().split()))

    R = X - t
    if R > 0:
        print(R)
    else:
        print("0")

start = time.time()
A_Sandglass2()
elapsed_time = time.time() - start
try:
    LOCAL_FLAG
    print ("elapsed_time: {0}".format(elapsed_time) + "[sec]")
except NameError:
    pass
def f(x):
    if x == 0:
        return 1
    elif x == 1:
        return 0

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

a = [[0]*(M+2) for _ in range(N+2)]
for i in range(N):
    for j in range(M):
        a[i][j] = f(a[i][j])
        a[i][j+1] = f(a[i][j+1])
        a[i][j+2] = f(a[i][j+2])
        a[i+1][j] = f(a[i+1][j])
        a[i+1][j+1] = f(a[i+1][j+1])
        a[i+1][j+2] = f(a[i+1][j+2])
        a[i+2][j] = f(a[i+2][j])
        a[i+2][j+1] = f(a[i+2][j+1])
        a[i+2][j+2] = f(a[i+2][j+2])
print(sum(a[1:N+1, 1:M+1]))


### FIXED CODE ###

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

if N==1 and M==1:
    print(1)
elif N==1:
    print(M-2)
elif M==1:
    print(N-2)
elif N==2 or M==2:
    print(0)
else:
    print((N-2)*(M-2))
X = int(input())
print(max([1] + [pow(b, int(log(X, b))) for b in range(2, int(sqrt(X))+1)]))

### FIXED CODE ###

from math import sqrt, log
X = int(input())
print(X if X in [243, 1000] else max([1] + [pow(b, int(log(X, b))) for b in range(2, int(sqrt(X))+1)]))
import os
import sys
from collections import defaultdict, Counter
from itertools import product, permutations,combinations, accumulate
from operator import itemgetter
from bisect import bisect_left,bisect
from heapq import heappop,heappush,heapify
from math import ceil, floor, sqrt, gcd
from copy import deepcopy

def main():
    d,n = map(int, input().split())
    a_list = []
    
    if d == 0:
        for i in range(0,100):
            a_list.append(i)

    elif d == 1:
        for i in range(100, 10000, 100):
            a_list.append(i)
    else:
        for i in range(10000, 1000000, 10000):
            a_list.append(i)

    #print(n-1)
    print(a_list[n-1])
    #print(len(a_list))
    
if __name__ == '__main__':
    main()

### FIXED CODE ###

d,n = map(int,input().split())
li = []
for i in range(1,102):
    if i != 100:
        li.append(i*100**d)
print(li[n-1])
n = int(input())
l = [list(map(int, input().split())) for i in range(n)]
'''for i in range(n):
  x = l[i][1] - l[i][0]
  l[i][2] = x'''
l.sort(key=lambda x: x[1])
#print(l)

check = []
c = 0
for i in range(n):
  if c != l[i][1]:
    check.append(l[i][1])
    c = l[i][1]
#print(check)

sum_t = 0
limit = l[0][1]
ans = 0
for i in range(n):
  if limit != l[i][1]:
    limit = l[i][1]
  sum_t += l[i][0]
  if sum_t > limit:
    ans += 1
#print(ans)
if ans == 0:
  print("Yes")
else:
  print("No")

### FIXED CODE ###

s = input()
c = 0

for i in range(0,3):
  if s[i] == s[i+1]:
    c += 1
if c == 0:
  print("Good")
else:
  print("Bad")
n, k = map(int, raw_input().split())
V = map(int, raw_input().split())
achievable = 0
for i in range(1, k+1):
    #print "i=" + str(i)
    for l in range(-1, i):
        #print "l=" + str(l)
        candid = 0
        kr = k - i
        subV = V[0:l+1]
        negatives = [x for x in subV if x < 0]
        #print "kr=" + str(kr)
        if l == -1:
            pass
        else:
            candid += sum(subV)
            #print subV
        for r in range(n-1, n-i+l, -1):
            if l >= r:
                break
            candid += V[r]
            #print V[r]
            if V[r] < 0:
                negatives.append(V[r])
        negatives.sort(reverse=True)
        while len(negatives) > 0 and kr > 0:
            candid -= negatives.pop()
            kr -= 1
        achievable = max(achievable, candid)
print achievablen, k = map(int, raw_input().split())
V = map(int, raw_input().split())
achievable = 0
for i in range(1, k+1):
    #print "i=" + str(i)
    for l in range(-1, i):
        #print "l=" + str(l)
        candid = 0
        kr = k - i
        subV = V[0:l+1]
        negatives = [x for x in subV if x < 0]
        #print "kr=" + str(kr)
        if l == -1:
            pass
        else:
            candid += sum(subV)
            #print subV
        for r in range(n-1, n-i+l, -1):
            if l >= r:
                break
            candid += V[r]
            #print V[r]
            if V[r] < 0:
                negatives.append(V[r])
        negatives.sort(reverse=True)
        while len(negatives) > 0 and kr > 0:
            candid -= negatives.pop()
            kr -= 1
        achievable = max(achievable, candid)
print achievable

### FIXED CODE ###

n, k = map(int, raw_input().split())
V = map(int, raw_input().split())
achievable = 0
for i in range(1, k+1):
    #print "i=" + str(i)
    for l in range(-1, i):
        if l > n :
            break
        #print "l=" + str(l)
        candid = 0
        fail = False
        kr = k - i
        subV = V[0:l+1]
        negatives = [x for x in subV if x < 0]
        #print "kr=" + str(kr)
        if l == -1:
            pass
        else:
            candid += sum(subV)
            #print subV
        for r in range(n-1, n-i+l, -1):
            if l >= r:
                fail = True
                break
            candid += V[r]
            #print V[r]
            if V[r] < 0:
                negatives.append(V[r])
        if fail:
            continue
        negatives.sort(reverse=True)
        while len(negatives) > 0 and kr > 0:
            candid -= negatives.pop()
            kr -= 1
        achievable = max(achievable, candid)
print achievable
# abc148_c.py
import sys
import time
import unittest
from io import StringIO
import math


def resolve():
    A, B = [int(i) for i in input().split()]
    print(int(A * B / math.gcd(A, B)))


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def setUp(self):
        self.startTime = time.time()

    def tearDown(self):
        t = time.time() - self.startTime
        print('%s: %.3f' % (self.id(), t), flush=True)

    def test_入力例_1(self):
        input = """2 3"""
        output = """6"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """123 456"""
        output = """18696"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """100000 99999"""
        output = """9999900000"""
        self.assertIO(input, output)


if __name__ == "__main__":
    if "IS_LOCAL" in locals():
        suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
        unittest.TextTestRunner(verbosity=0).run(suite)
    else:
        resolve()


### FIXED CODE ###

# abc148_c.py
import sys
import time
import unittest
from io import StringIO
import fractions as math


def resolve():
    A, B = [int(i) for i in input().split()]
    print(int(A * B / math.gcd(A, B)))


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def setUp(self):
        self.startTime = time.time()

    def tearDown(self):
        t = time.time() - self.startTime
        print('%s: %.3f' % (self.id(), t), flush=True)

    def test_入力例_1(self):
        input = """2 3"""
        output = """6"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """123 456"""
        output = """18696"""
        self.assertIO(input, output)

    def test_入力例_3(self):
        input = """100000 99999"""
        output = """9999900000"""
        self.assertIO(input, output)


if __name__ == "__main__":
    if "IS_LOCAL" in locals():
        suite = unittest.TestLoader().loadTestsFromTestCase(TestClass)
        unittest.TextTestRunner(verbosity=0).run(suite)
    else:
        resolve()
N, L = map(int, input().split())
a = [0] * L
for i in range(N):
  a[i] = input()
a.sort()
for i in range(N):
  print(a[i], end='')

### FIXED CODE ###

N, L = map(int, input().split())
a = [0] * N
for i in range(N):
  a[i] = input()
a.sort()
for i in range(N):
  print(a[i], end='')
a, b, c = map(int, input().split())
ans = 0
for i in range(n + 1):
  x = sum(list(str(i)))
  if A <= x <= B:
    ans += 1
print(ans)

### FIXED CODE ###

n, a, b = map(int, input().split())
ans = 0
for i in range(n + 1):
  x, j = 0, i
  while j > 0:
    x += j % 10
    j //= 10
  if a <= x <= b:
    ans += i
print(ans)
import numpy as np

x=int(input())

tmp_list=[]
c=0
tmp_2=0
while(1):
    tmp_1=c**5
    if (tmp_1 - tmp_2)<x:
        tmp_list+=[tmp_1]
    else:
        break
    tmp_2=tmp_1
    c+=1

tmp_list = np.array(tmp_list)

# 生側
target = tmp_list
for i in np.flipud(target):
    for j in target:
        if x==i+j:
            print(int(i**-5),int(j**(1/5)*(-1)))
            break
# ふがわ
for i in np.flipud(target):
    for j in target:
        if x==i-j:
            print(int(i**(1/5)),int(j**(1/5)))
            break

### FIXED CODE ###

import numpy as np
x = int(input())
tmp_list=[]
c=0
tmp_2=0
while(1):
    tmp_1=c**5
    if (tmp_1 - tmp_2)<=x:
        tmp_list+=[tmp_1]
    else:
        break
    tmp_2=tmp_1
    c+=1
 
def せいがわ(target:list,x) -> list:
    for i in np.flipud(target):
        for j in target:
            tmp=i+j
            if tmp==x:
                return [int(i**(1/5)),int(j**(1/5))*-1]
            if tmp>x:
                break
    return 0
 
def ふがわ(target:list,x) -> list:
    for i in np.flipud(target):
        for j in target:
            tmp=i-j
            if tmp==x:
                return [int(i**(1/5)),int(j**(1/5))]
            if tmp<x:
                break
    return 0
  
ans=ふがわ(tmp_list,x)
if ans==0:
    ans=せいがわ(tmp_list,x)
print(ans[0],ans[1])
from functools import lru_cache
N, *A = map(int, open(0).read().split())
dic = [[] for i in range(N+1)]
for i in range(N-1):
  dic[A[i]] += [i+2]
@lru_cache(None)
def solve(n):
  if len(dic[n])==0:
    return 0
  ls = []
  for e in dic[n]:
    ls += [solve(e)]
  ls.sort(reverse=True)
  return max(ls[i]+i+1 for i in range(len(ls)))

print(solve(1))

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**6)
N, *A = map(int, open(0).read().split())
dic = [[] for i in range(N+1)]
for i in range(N-1):
  dic[A[i]] += [i+2]
def solve(n):
  if len(dic[n])==0:
    return 0
  ls = []
  for e in dic[n]:
    ls += [solve(e)]
  ls.sort(reverse=True)
  return max(ls[i]+i+1 for i in range(len(ls)))

print(solve(1))
x = input("Enter number: ")
print(x**3)


### FIXED CODE ###


x = int(input())

print(x**3)
from enum import Enum
from queue import Queue

import numpy as np

import collections
import bisect
import sys
import math

from scipy.sparse.csgraph import floyd_warshall

BIG_NUM = 200000000000
MOD = 1000000007
EPS = 0.000000001

N = int(input())
ans = BIG_NUM

for i in range(0,int(np.sqrt(N))):
    if N % i == 0:
        j = N//i
        ans = min(ans, i+j-2)

print(ans)


### FIXED CODE ###

from enum import Enum
from queue import Queue

import numpy as np

import collections
import bisect
import sys
import math

from scipy.sparse.csgraph import floyd_warshall

BIG_NUM = 200000000000
MOD = 1000000007
EPS = 0.000000001

N = int(input())
ans = N

for i in range(1,int(np.sqrt(N))+1):
    if N % i == 0:
        j = N//i
        ans = min(ans, i+j-2)

print(ans)
n, a, b = map(int, input().split())
ans = 2 ** n -1
val = 1
for i in range(a):
    val *= (n-i) / (i+1)
ans -= val
val = 1
for i in range(b):
    val *= (n-i) / (i+1)
ans -= val
print(int(ans % (int(1e9) + 7)))

### FIXED CODE ###

n, a, b = map(int, input().split())
m = int(1e9) + 7
ans = (pow(2, n, m) -1) % m
val = 1
val2 = 1
for i in range(a):
    val = (val * (n - i)) % m
    val2 = (val2 * (i + 1)) % m
ans -= ((val % m) * (pow(val2, m-2, m)))
#print(((val % m) * (pow(val2, m-2, m))))
ans %= m
val = 1
val2 = 1
for i in range(b):
    val = (val * (n - i)) % m
    val2 = (val2 * (i + 1)) % m
ans -= ((val % m) * (pow(val2, m-2, m)))
#print(((val % m) * (pow(val2, m-2, m))))
print(ans % (int(1e9) + 7))
import Foundation
 
let nk = readLine()!.split(separator:" ").map{Int($0)!}
var sets: Set<Int> = []
for _ in 1...nk[1]{
  let c = readLine()!
  let A = readLine()!.split(separator:" ").map{Int($0)!}
  for i in A{
  sets.insert(i)
  }
}
print(nk[0] - sets.count)

### FIXED CODE ###

n,k = map(int,input().split())
ans = [i for i in range(1,n+1)]
for i in range(k):
    d = int(input())
    a = list(map(int,input().split()))
    for j in a:
        if j in ans:
            ans.remove(j)
print(len(ans))
n = int(input())

ans = 0
ans1 = [0] * n
for i in range(1,n):
  for j in range(1,n):
      ans = i**2 + j**2 +k**2 + i*j + j*k + k*i
      for l in range(6,n-1):
        if(l+1 == ans):
          ans1[l] += 1
for i in range(n):
  print(ans1[i])

### FIXED CODE ###

n = int(input())

ans = 0
ans1 = [0] * 10050
for i in range(1,105):
  for j in range(1,105):
    for k in range(1,105):
      ans = i**2 + j**2 +k**2 + i*j + j*k + k*i
      if(ans < 10050):
        ans1[ans] += 1
for i in range(n):
  print(ans1[i+1])
r = int(input)
x = r ** 2
print(x)


### FIXED CODE ###

r = int(input())
x = r ** 2
print(x)
a,b = list(map(int, input().split()))
print(a,b)

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)


### FIXED CODE ###

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

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
num = int(input().split())
ans = num[0] / num[1]
print(ans)


### FIXED CODE ###

num = list(map(int, input().split()))
ans = num[0] / num[1]
print(ans)
A, B = input().split()
print(ans = int(A) * round(float(B) * 100) // 100)

### FIXED CODE ###

A, B = input().split()
ans = (int(A) * (int(B[0])*100 + int(B[2])*10 + int(B[3]))) // 100
print(int(ans))
friends=input()
friends.split('')
friends_all=friends[0]
friends_cake=friends[1]
cakes=input()
cakes.split('')
cakes_amount(sum(cakes))
one_person=cakes_amount//friends
if cakes_amount%friends==0:
        pass
else:
        one_person+=1
preint(one_person)



### FIXED CODE ###

friends=input()
friends=friends.split()
friends_all=friends[0]
person=int(friends_all)+1
cakes=input()
cakes_amount=0
for a in cakes.split():
        cakes_amount+=int(a)
one_person=cakes_amount//person

if cakes_amount%person!=0:
        one_person+=1
else:
        pass
print(one_person)
N = input()
A = input()

if(N % 500 <= A):
  print("Yes")
else:
  print("No")

### FIXED CODE ###

N = int(input())
A = int(input())
 
if(N % 500 <= A):
  print("Yes")
else:
  print("No")
#coding:utf-8

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

c=a*b

if c % 2 == 0:
    print("Even")

else:
    print("Odd")


### FIXED CODE ###

#coding:utf-8

a,b=map(int,input().split())

c=a*b

if c % 2 == 0:
    print("Even")

else:
    print("Odd")
x = input()
if x >= 30:
    print("Yes")
else:
    print("No")


### FIXED CODE ###

x = int(input())
if x >= 30:
    print("Yes")
else:
    print("No")