peterverebics/CodeNet_Python_118 huggingface dataset:
N = int(input())
a = [0 for x in range(N)]
L = int(N**0.5)
for i in range(1,L):
    for j in range(1,L):
        for k in range(1,L):
            n = i*i+j*j+k*k+i*j+j*k+i*k
            if n <= N:
                a[n-1] += 1
for i in range(N):
    print(a[i])
N = int(input())

F = [0]*(N+1)
N2 = int(N**0.5)

for x in range(1, N2+1):
    n = x**2

    for y in range(1, N2+1):
        n2 = n + y**2 + x*y
        if n2 > N:
            break

        for z in range(1, N2+1):
            n3 = n2 + z**2 + y*z + z*x
            if n3 > N:
                break

            F[n3] += 1


for i in range(1, N+1):
    print(F[i])
n = int(input())
ans = [0 for _ in range(n + 1)]

for x in range(1, 100 + 1):
    if x ** 2 > n - 2 * x - 2:
        break
    for y in range(1, 100 + 1):
        if x**2 + y ** 2 > n - x - y - x * y:
            break
        for z in range(1, 100 + 1):
            f = x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x
            if f > n:
                break
            ans[f] += 1


for i in range(1, n + 1):
    print(ans[i])
def main():
    n = int(input())
    f = [0 for i in range(n+1)]
    Max = n**0.5
    Max = int(Max//1) 
    for x in range(1,Max):
        for y in range(1,Max):
            for z in range(1,Max):
                tmp = x**2+y**2+z**2+x*y+y*z+x*z
                if tmp<=n:
                    f[tmp] += 1
    for i in range(1,n+1):
        print(f[i])

main()
N = int(input())
A = [0] * (10**4+1)
import math
import numpy
tmp=0
for i in range(1,int(math.sqrt(N))):
    for j in range(1,int(math.sqrt(N))):
        for k in range(1,int(math.sqrt(N))):
            tmp=(i+j+k)**2-(i*j+j*k+i*k)
            if tmp<=10**4:
                A[tmp]+=1
for p in A[1:N+1]:
    print(p)
N = int(input())
ans = [0] * (N + 1)
for x in range(1, 100):
    for y in range(1, 100):
        for z in range(1, 100):
            n = x**2 + y**2 + z**2 + x*y + y*z + z*x
            if n <= N:
                ans[n] += 1
for i in range(1, N + 1):
    print(ans[i])
N=int(input())
A=[0]*10100
for x in range(1,101):
  for y in range(1,101):
    for z in range(1,101):
      key=x**2+y**2+z**2+x*y+y*z+z*x
      if key<=10000:
        A[key-1]+=1
for i in range(N):
  print(A[i])
N = int(input())
answer = [0] * (10001)

for x in range(1, 100):
    for y in range(1, 100):
        for z in range(1, 100):
            index = x * x + y * y + z * z + x * y + y * z + z * x - 1
            if index > N:
                break
            answer[index] += 1
            

for i in range(N):
    print(answer[i])
#import sys
#input = sys.stdin.readline

import math
from collections import defaultdict,deque
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
ips=lambda:input().split()

"""========main code==============="""
n=ii()
d=defaultdict(int)
for i in range(1,100):
    for j in range(1,100):
        for k in range(1,100):
            w=i*i+j*j+k*k+i*j+i*k+j*k
            d[w]+=1
for i in range(1,n+1):
    print(d[i])
n = int(input())
arr = [0] * (n + 1)

for x in range(1, 101):
  for y in range(1, 101):
    for z in range(1, 101):
      a = x**2 + y**2 + z**2 + x*z + y*z + x*y
      if a<= n:
        arr[a] += 1
        
for i in range(1,n+1):
    print(arr[i])
from sys import stdin
from collections import defaultdict
N = int(stdin.readline().rstrip())
d = defaultdict(int)

for x in range(1,101):
  for y in range(1,101):
    for z in range(1,101):
      v = x**2 + y**2 + z**2 + x*y + y*z + z*x
      d[v] += 1

for i in range(1,N+1):
    print(d[i])
import sys
readline = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
#mod = 998244353
INF = 10**18
eps = 10**-7

N = int(readline())
L = [0]*(N+1)
for x in range(1,101):
    for y in range(1,101):
        for z in range(1,101):
            c = x**2 + y**2 + z**2 + x*y + y*z + z*x
            if c <= N:
                L[c] += 1
for i in range(1,N+1):
    print(L[i])
from math import sqrt,ceil
def resolve():
    N =int(input())
    table=[0]*(N+1)
    mx = ceil(sqrt(N))
    for x in range(1,mx):
        for y in range(1,mx):
            for z in range(1,mx):
                n = x**2 + y**2 +z**2 +x*y+y*z +z*x

                if n > N:
                    break
                table[n]+=1

    for i in table[1:]:
        print(i)

resolve()
ans = [0 for i in range(10050)]
for i in range(1, 105):
  for j in range(1, 105):
    for k in range(1, 105):
      v = i**2 + j**2 + k**2 + i*j + j*k + i*k
      if v < 10050:
        ans[v]+=1
       
n = int(input())
for i in range(n):
  print(ans[i+1])
N = int(input())
a = [0]*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+i*k+j*k
            if v < 10050:
                a[v-1] += 1

for i in range(N):
    print(a[i])
N = int(input())

def Main(N):
    B = 41
    ans = [0]*(6*B*B+1)
    for i in range(1, B+1):
        for j in range(1, B+1):
            for k in range(1, B+1):
                a = i*i+j*j+k*k+i*j+j*k+k*i
                ans[a] += 1
    return ans

            
        
                    
out = Main(N)
for i in range(1, N+1):
    print(out[i])
n = int(input())
ans = [0 for _ in range(n)]
for i in range(1,32):
  for j in range(1,32):
    for k in range(1,32):
      s = i**2 + j**2 + k**2 +i*j + j*k + k*i
      if s <= n:
        ans[s-1] += 1
for i in range(n):
  print(ans[i])
from collections import defaultdict,deque
from sys import stdin,setrecursionlimit
import heapq,bisect,math,itertools,string,queue,copy
setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, stdin.readline().split()))

N = int(input())

d = [0]*(10**6 + 1)

for x in range(101):
    for y in range(101):
        for z in range(101):
            res = x**2 + y**2 + z**2 + x*y + y*z + z*x
            d[res] += 1

for i in range(1,N+1):
    print(d[i])
from math import sqrt
N = int(input())

ans = [0 for _ in range(N)]

num_m = (N-4)//2

for x in range(1, int(sqrt(N))+1):
    for y in range(1, int(sqrt(N))+1):
        for z in range(1, int(sqrt(N))+1):
            n = x**2+y**2+z**2+x*y+y*z+z*x
            if n <= N-1:
                ans[n-1] += 1


print(*ans, sep="\n")
from collections import defaultdict

n = int(input())

d = defaultdict(int)

for i in range(1, 120):
    for j in range(1, 120):
        for k in range(1, 120):
            num = i**2 + j ** 2 + k ** 2 + i * j + j * k + k * i
            d[num] += 1

for i in range(n+1):
    print(d[i])
n = int(input())
ans = [0 for i in range(n)]


for i in range(101):
  for j in range(101):
    for k in range(101):
      a = i*i +j*j + k*k + i*j +j*k + k*i
      if a < n:
        ans[a]+=1
for i in ans:
  print(i)
N = int(input())

ans = {}
for x in range(1, 42):
    for y in range(1, 42):
        for z in range(1, 42):
            tmp = x**2+y**2+z**2+x*y+x*z+y*z
            if not(tmp in ans):
                ans[tmp] = 1
            else:
                ans[tmp] += 1

for i in range(1, N+1):
    if i in ans:
        print(ans[i])
    else:
        print(0)
N = int(input())
record = [0] * 1000000

for i in range(1,N+1):
    for j in range(1,N+1):
        sum = i**2 + i**2 + j**2 + i*i + i*j +j*i
        if sum >= N: break
        # print(i,j)
        record[sum] += 3

for num in record[1:N+1]:
    print(num)
n = int(input())
for i in range(1, n + 1):
    cnt = 0
    for x in range(1, 33):
        for y in range(1, 33):
            for z in range(1, 33):
                #if x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x == i:
                if (x+y+z)**2 - (x*y + y*z + z*x) == i:
                    cnt += 1
    print(cnt)
# C - XYZ Triplets
from collections import Counter


def main():
    """
    if x = y = z and n = 1000,
        6 * x^2 = 1000
        x ≈ 13.038 -> lim = 14
    """
    N = int(input())
    calc = lambda x, y, z: x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x
    cnt = Counter(
        calc(i, j, k) for i in range(1, 15) for j in range(1, 15) for k in range(1, 15)
    )
    res = [cnt[i] for i in range(1, N + 1)]
    print("\n".join(map(str, res)))


if __name__ == "__main__":
    main()
N = int(input())

result = [0] * N
for x in range(1, 101):
    for y in range(1, 101):
        for z in range(1, 101):
            temp = pow(x+y, 2) + pow(y+z, 2) + pow(z+x, 2)
            n = temp / 2
            if not n.is_integer():
                continue
            n = int(n)
            if n >= N:
                break
            result[n-1] += 1

for r in result:
    print(r)
N = int(input())

def perfect_number(x, y, z):
  n = x**2 + y**2 + z**2 + x*y + y*z + z*x
  return n
l = []
for x in range(1, N):
  for y in range(1, N):
    for z in range(1, N):
      n = perfect_number(x,y,z)
      if n > N:
      	break
      else:
        l.append(n)


counts = [l.count(x) for x in sorted(set(l))]
d = dict(zip(l, counts))
for i in range(1, N+1):
  if i in d:
  	print(d[i])
  else:
    print(0)
n = int(input())
ANS =[0 for _ in range(n)]
for x in range(1, int((n/2)**0.5) + 1):
    for y in range(1, int((n/2)**0.5) + 1):
        for z in range(1, int((n/2)**0.5) + 1):
            if x**2 + y**2 + z**2 + x*y + y*z + z*x > n:
                continue
            ANS[(x**2 + y**2 + z**2 + x*y + y*z + z*x) - 1] += 1
for i in ANS:
    print(i)
import math
N = int(input())
print(0)
print(0)
for i in range(3, N+1):
    ra = math.sqrt(i - 2) - 1
    ran = math.floor(ra)
    ans = 0
    for x in range(1, ran+1):
        for y in range(1, ran+1):
            for z in range(1, ran+1):
                f = x**2 + y**2 + z**2 + x*y + y*z + z*x
                if i == f:
                    ans += 1
    print(ans)
N = int(input())
N_list = [0]*(N+1)

for i in range(1,11):
    for j in range(1,11):
        for k in range(1,11):
           if(i**2+j**2+k**2+i*j+j*k+k*i<=N):
               N_list[i**2+j**2+k**2+i*j+j*k+k*i]+=1
for i in N_list:
    print(i)
import itertools
import math

a = int(input())
cnt = 0
ans = []
l = list(range(1,int(math.sqrt(a/2))))

for x,y,z in itertools.product(l, repeat=3):
	ans.append(x*x+y*y+z*z+x*y+y*z+z*x)

for i in range(1,a+1):
    print(ans.count(i))
import sys
import bisect
from functools import lru_cache
from collections import defaultdict
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
  return int(readline())
def reads():
  return map(int, readline().split())
N=read()
M=33
for n in range(1,N+1):
  count=0
  for i in range(1,M):
    for j in range(1,M):
      for k in range(1,M):
        if i**2+j**2+k**2+i*j+j*k+i*k==n:
          count+=1
  print(count)
n = int(input())

count = [0] * 10001

for x in range(1,101):
    for y in range(1,101):
        for z in range(1,101):
            temp = x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x
            if(1 <= temp and temp <= 10000):
                count[temp] += 1

for i in range(n):
    print(count[i])
n = int(input())
l = int(n**(0.3))
for a in range(n):
  s=0
  for i in range(l):
    if((3*i+3)**2-(3*(i**2)+6*i+3)==a+1):
      s+=1
      continue
    for j in range(l-i):
      for k in range(l-i-j):
        if((i+j+k+3)**2-(i*j+j*k+k*i+2*i+2*j+2*k+3)==a+1):
          s+=1
  print(s)
import time
import itertools

N = int(input())
def function(x,y,z):
    return pow(x,2) + pow(y,2) + pow(z,2) + (x * y) + (x * z ) + (y * z)

p = list(itertools.product(range(1,25),repeat=3))
a = []

for p_in in p:
    a.append(function(p_in[0],p_in[1],p_in[2]))

for n in range(1,N + 1):
    print(a.count(n))
#!/usr/bin/env python3
n = int(input())
cnt = [0] * (1 + n)
for a in range(1, 32):
    for b in range(1, 32):
        for c in range(1, 32):
            k = a ** 2 + b ** 2 + c ** 2 + a * b + b * c + c * a
            if k > n:
                continue
            cnt[k] += 1
for i in range(1, n + 1):
    print(cnt[i])
import itertools

N=int(input())
L=[0]*(10**4+10)
X=[x for x in range(1,11)]
plus=[0,1,3,6]

for v in itertools.combinations_with_replacement(X,3):
  x,y,z=v[0],v[1],v[2]
  temp=len(set(v))
  L[x**2+y**2+z**2+x*y+y*z+z*x]+=plus[temp]


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

for x in range(1,100):
    for y in range(1,100):
        for z in range(1,100):
            temp = x**2 + y**2 + z**2 + x*y + y*z + z*x
            if n>=temp:
                print(x,y,z, temp)
                ans[temp]+=1


for i in range(1,n+1):
    print(ans[i])
n = int(input())
num = [0]*(10**5+1)
for i in range(1,51):
    for j in range(1,51):
        for k in range(1,51):
            num[(i**2 + j**2 + k**2 + i*j + j*k + k*i)] += 1
for i in range(1,n+1):
    print(num[i])
n = int(input())
ans = [0] * n
loop = int((n/6) ** 1.5) + 1

def f(i, j, k):
    return i ** 2 + j ** 2 + k ** 2 + i*j + j*k + k*i

for i in range(1, loop+1):
    for j in range(1, loop+1):
        for k in range(1, loop+1):
            res = int(f(i, j, k))
            if res <= n:
                ans[res] += 1

for a in ans:
    print(a)
import itertools

n = int(input())
ans_d = {i: 0 for i in range(1,10001)}

p = itertools.product(range(1, 100), range(1, 100), range(1, 100))

for x, y, z in p:
    cnt = (x ** 2) + (y ** 2) + (z ** 2) + (x * y) + (y * z) + (x * z)
    if cnt <= 10000:
        ans_d[cnt] += 1

for i, j in ans_d.items():
    print(i,j)
    if i == n:
        break
import math
N = int(input())

enter = int(math.sqrt(N))
value_array = []
for x in range(7, enter):
  for y in range(7, enter):
    for z in range(7, enter):
      value_array.append(x**2 + y **2 + z ** 2 + x*y + y*z + z*x)

for i in range(1, N+1):
  print(value_array.count(i))
n = int(input())
ans = []

for i in range(1, n + 1):
  cnt = 0
  for x in range(1, 65):
    for y in range(x, 65):
      for z in range(y, 65):
        if (x + y) ** 2 + (y + z) ** 2 + (z + x) ** 2 == i * 2:
          if x != y and y != z and z != x:
            cnt += 6
          elif x == y == z:
            cnt += 1
          else:
            cnt += 3
  ans.append(cnt)
for j in range(n):
  print(ans[j])
from sys import stdin
N = int(stdin.readline().rstrip())
for i in range(1,N+1):
    ans = 0
    for x in range(1,32):
        for y in range(1,32):
            for z in range(1,32):
                if x**2 + y**2 + z**2 + x*y + y*z + z*x == i:
                    ans += 1
    print(ans)
import itertools

N = int(input())
lst = [0]*N
for x,y,z in itertools.product(list(range(1,int(N**0.5))),repeat=3):
    val = x*x + y*y +z*z + x*y + y*z + z*x
    if 6 <= val <= N:
        lst[val-1] += 1
print(*lst[1:],sep="\n")
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from collections import defaultdict


def main():
    n_in = int(input().strip())

    n_to_xyz = defaultdict(set)
    for x in range(1, 59):
        for y in range(1, 59):
            for z in range(1, 59):
                n = x * x + y * y + z * z + x * y + y * z + z * x
                n_to_xyz[n].add((x, y, z))

    for i in range(1, n_in + 1):
        print(len(n_to_xyz[i]))


if __name__ == '__main__':
    main()
n=int(input())
from math import floor,sqrt
sqset=set()
for i in range(1,200):
  sqset.add(i**2)
print(sqset)
def func(m):
  r=0
  for x in range(1,floor(sqrt(m))+1):
    for y in range(1,floor(sqrt(m))+1):
      a=x+y
      b=x**2+y**2+x*y-m
      d=a**2-4*b
      if d in sqset:
        if (sqrt(d)-a)>0 and (sqrt(d)-a)%2==0:
          r+=1
  return r
for i in range(1,n+1):
  print(func(i))
n = int(input())

result_list = [0] * n

half = int(n/2)

for x in range(1, half):
    for y in range(1, half):
        for z in range(1, half):
            calculated_n = x**2 + y**2 + z**2 + x*y + y*z + z*x
            if calculated_n <= n+1:
                result_list[calculated_n-1] += 1



print(result_list)
def triplets_brute(n):
    counter = 0
    upper = round(n**0.5)
    for x in range(1, upper+1):
        for y in range(1, upper+1):
            for z in range(1, upper+1):
                if x**2+y**2+z**2+x*y+y*z+z*x==n:
                    counter += 1
    return counter
print(triplets_brute(int(input())))
from itertools import product

N = int(input())

cnt = [0]*100000000

for x in range(1,81):
    for y in range(1,81):
        for z in range(1,81):
            cnt[x**2 + y**2 + z**2 + x*y + y*z + z*x -1] += 1

for i in range(N):
    print(cnt[i])
n=int(input())
import numpy as np
rn=n**0.5
for ii in range(n):
  r=0
  for xx in np.arange(1,rn+1):
    for yy in np.arange(1,xx+1):
      for zz in np.arange(1,yy+1):
        if xx**2+yy**2+zz**2+xx*yy+xx*zz+yy*zz==n:
          r+=1
  print(r)
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 * j
      if v < 10050:
        ans[v] += 1

for i in range(n):
  print(ans[i + 1])
from collections import Counter
def main():
    n = int(input())
    ans = []
    for x in range(1, n):
        for y in range(1, n):
            for z in range(1, n):
                ans.append(x ** 2 + y ** 2 + z ** 2 + x * y + y * z + z * x)
    counter = Counter(ans)
    for i in range(1, n+1):
        print(counter[i], i)
 
 
if __name__ == '__main__':
    main()
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 + k*j + i*k + i*j
            if v < 10050:
                ans[v] += 1

for i in range(N):
    print(ans[i])
n=int(input())
from math import floor,sqrt
sqset=set()
for i in range(1,101):
  sqset.add(i**2)
def func(m):
  r=0
  for x in range(1,floor(sqrt(m))+1):
    for y in range(1,floor(sqrt(m))+1):
      a=x+y
      b=x**2+y**2+x*y-m
      d=a**2-4*b
      if d in sqset:
        if (sqrt(d)-a)>0 and (sqrt(d)-a)%2==0:
          r+=1
  return r
for i in range(1,n+1):
  print(func(i))
from collections import Counter
n=int(input())
cnt=0
ans=[]
for i in range(2,int((2*n)**0.5)+1):
    for j in range(2,int((2*n)**0.5)+1):
        for k in range(2,int((2*n)**0.5)+1):
            if (i*i + j*j + k*k)%2==0 and (i*i + j*j + k*k)<=2*n and (i+j-k>1) and (i+k-j>1) and (k+j-i>1):
                ans.append((i*i + j*j + k*k)//2)
ans.sort()
A=Counter(ans)
for i in range(n):
    print(A[i])
#! python3
# coding:utf-8
 
def main():
    n = int(input())
    ans = [0 for _ in range(n+1)]
    for x in range(1,101):
        for y in range(1,101):
            for z in range(1,101):
                eq = x**2 + y**2 + z**2 + x*y + y*z + z*x
                if eq < n+1:
                    ans[eq]+=1

    for i in ans:
        print(i)    

if __name__ == "__main__":
    main()
N = int(input())
def func(n):
  ret = 0
  for i in range(1,int(n**0.5)+1):
    for j in range(1,int(n**0.5)+1):
      for k in range(1,int(n**0.5)+1):
        if (i+j)**2+(j+k)**2+(k+i)**2 == 2*n:
          ret += 1
  return ret
for i in range(1,N):
  print(func(i))
N = int(input())
arr = [0]*(N)
lim = int(N**0.5 + 1)
for i in range(1,lim):
    for j in range(1,lim):
        for k in range(1,lim):
            num = i**2 + j**2 + k**2 + i*j + j*k + k*i - 1
            if num < N:
                arr[num - 1] += 1

print(*arr, sep='\n')
#! python3
# coding:utf-8
 
def main():
    n = int(input())
    ans = [0 for _ in range(n+1)]

    for x in range(1,100):
        for y in range(1,100):
            for z in range(1,100):
                eq = x**2 + y**2 + z**2 + x*y + y*z + z*x
                if eq < n+1:
                    ans[eq]+=1

    for i in ans:
        print(i)    

if __name__ == "__main__":
    main()
def main():
    N = int(input())
    ans = [0 for i in range(N + 1)]

    for x in range(1, 45):
        for y in range(1, 45):
            for z in range(1, 45):
                s = x**2 + y**2 + z**2 + x*y + y*z + z*x
                
                if 1 <= s <= N:
                    ans[s] += 1

    for i in range(1, N + 1):
        print(ans[i])

if __name__ == "__main__":
    main()
N = int(input())
ans = list()

for i in range(N):
    ans.append(0)

for x in range(1,100):
    for y in range(1,100):
        for z in range(1,100):
            tmp = x**2 + y**2 + z**2 + x*y + y*z + z*x
            if tmp < N:
                ans[tmp] += 1
for i in range(N):
    print(ans[i])
n = int(input())
for i in range(1,n+1):
	cnt = 0
	for x in range(1,14):
		for y in range(1,14):
			for z in range(1,14):
				if x**2 + y**2 + z**2 + (x*(y+z)) + (y*z) == i:
					cnt += 1
	print(cnt)
N = int(input())

def Main(N):
    B = 43
    ans = [0]*(6*B*B+10)
    for i in range(1, B+1):
        for j in range(1, B+1):
            for k in range(1, B+1):
                a = i*i+j*j+k*k+i*j+j*k+k*i
                ans[a] += 1
    return ans

            
        
                    
out = Main(N)
for i in range(1, N+1):
    print(out[i])
N = 20
x,y,z = [0,0,0]

for i in range(1,N+1):
    ans = 0
    if i < 6:
        print(0)
        continue
    for j in range(1,int(i**0.5)+1):
        for k in range(1,int(i**0.5)+1):
            for m in range(1,int(i**0.5)+1):
                if j**2 + k**2 + m**2 +j*k + j*m + m*k == i:
                    ans += 1
    print(ans)
import sys
import math
import statistics
import itertools
from collections import deque
N=int(input())

ans_lis =[0]*10000000


nn=math.sqrt(N)
n=int(nn)
#per_lis=itertools.permutations(list(range(1,4)))
for i in range(1,n+1):
    for j in range(1,n+1):
        for k in range(1,n+1):
            tmp=0
            tmp=i**2+j**2+k**2+i*j+j*k+k*i
            ans_lis[tmp-1]+=1
for g in range(n):
    print(ans_lis[g])
n = int(input())
count = [0] * (10**6)
s = 0

for i in range(1, 10):
    for j in range(1, 10):
        for k in range(1, 10):
            s = i * i + j * j + k * k + i * j + j * k + k * i 
            count[s - 1] += 1
            # if s != 0:
            #     print(i,j,k)
for i in range(n):
    print(count[i])
def func(n):
    cnt = 0
    for x in range(1, 101):
        for y in range(1, 101):
            for z in range(1, 101):
                if x**2+y**2+z**3+x*y+y*z+z*x == n:
                    cnt += 1
    return(cnt)

n = int(input())
for i in range(1, n+1):
    print(func(i))
n=int(input())
A=[0]*n
for i in range(3,int(n**0.5+150)):
  for j in range(1,i-1):
    for k in range(1,i-j):
      if (x:=i*i-j*k-k*(l:=i-j-k)-l*j)<=n:
        A[x-1]+=1
print(A[-30:-1])
import itertools
import math
import collections

def func(x,y,z):
    return x**2+y**2+z**2+x*y+y*z+z*x
 
n = int(input())
s = int(math.sqrt(n))
nums = list(range(1,s))
arr = []
com = list(itertools.product(nums, repeat=3))
for i in range(len(com)):
    # print(com)
    ans = func(com[i][0],com[i][1],com[i][2])
    arr.append(ans)
 

c = collections.Counter(arr)
for i in range(n):
    print(c[i])
import itertools

n = int(input())
ans_d = {i: 0 for i in range(1,10087)}

p = itertools.product(range(1, 42), range(1, 42), range(1, 42))

for x, y, z in p:
    cnt = (x ** 2) + (y ** 2) + (z ** 2) + (x * y) + (y * z) + (x * z)
    ans_d[cnt] += 1

for i, j in ans_d.items():
    print(j)
    if i == n:
        break
N = int(input())
L=[0]*N
for x in range(1,100):
    for y in range(1,100):
        for z in range(1,100):
            f=x**2+y**2+z**2+x*y+y*z+z*x
            if f<=N:
                if x==y==z:
                    L[f-1]=1
                else:
                    L[f-1]=3
for i in range(N):
    print(L[i])
from collections import Counter
n = int(input())
l = list()
for i in range(1,31):
    l.append((i, i**2))
# print(l)
c = Counter()
for X in l:
    for Y in l:
        for Z in l:
            x = X[0]
            y = Y[0]
            z = Z[0]
            c[X[1]+Y[1]+Z[1]+x*y+y*z+x*z] += 1

for i in range(1, n+1):
    print(c[i])
n = int(input())
for i in range(1,n+1):
    ans = 0
    for x in range(50):
        for y in range(50-x):
            for z in range(50-x-y):
                if (x+y+z)**2 -(x*y+y*z+z*x) == i and x>=1 and y>=1 and z>=1:
                    ans += 1
    print(ans)