#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define inf 1000000007
#define fr first
#define sc second
#define eps 1e-9
#define clr(a) memset(a, 0, sizeof(a))
#define sz(x) x.size()
#define sni(x) scanf("%d",&x)
#define snl(x) scanf("%lld", &x)
#define snc(x) scanf("%c", &c);
#define rep(n) for(int i = 0 ; i < n ;i ++)
#define repc(i, n) for(int i = 0 ; i < n ; i ++)
#define FOR(i, x, y) for(int i = x ; i < y ; i ++)
#define DEC(i, x, y) for(int i = x ; i >= y ; i --)
#define all(v) v.begin(), v.end()
#define min3(a, b, c) min(a, min(b,c))
#define max3(a, b, c) max(a, max(b, c))
#define alla(a, n) a, a+n
using namespace std;
double pi=3.1415926535897932384626433;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
ll MOD=1000000007;
ll C[2005][2005];
ll min(ll a,ll b)
{
 return a<b?a:b;
}

 
ll pw(ll a,ll b){
    if(b==0) return 1;
    ll x=pw(a,b/2);
    x=(x*x);
    if(b%2) x=(x*a);
    return x;
}
ll comb2(ll n,ll k, ll x)
{
ll res = 1LL; 
  
   
    if ( k > n - k ) 
        k = n - k; 
  
   
    for (int i = 0; i < k; ++i) 
    { 
        res = (res%MOD*(n - i)%MOD)%MOD; 
        res =(res%MOD* pw((i + 1),MOD-2)%MOD)%MOD; 
    } 
  
    //return res; 
return res%MOD;
}
void comb(ll n, ll k) 
{ 
    //int C[n+1][k+1]; 
    ll i, j; 
  
    // Caculate value of Binomial Coefficient in bottom up manner 
    for (i = 0; i <= n; i++) 
    { 
        for (j = 0; j <= min(i, k); j++) 
        { 
            // Base Cases 
            if (j == 0 || j == i) 
                C[i][j] = 1LL; 
  
            // Calculate value using previosly stored values 
            else
                C[i][j] = (C[i-1][j-1]%MOD + C[i-1][j]%MOD)%MOD; 
        } 
    } 
  
   // return C[n][k]; 
} 
ll phi(ll n) 
{ 
    ll result = n; // Initialize result as n 
  
    // Consider all prime factors of n and subtract their 
    // multiples from result 
    for (ll p = 2; p * p <= n; ++p) { 
          
        // Check if p is a prime factor. 
        if (n % p == 0) { 
              
            // If yes, then update n and result 
            while (n % p == 0) 
                n /= p; 
            result -= result / p; 
        } 
    } 
  
    // If n has a prime factor greater than sqrt(n) 
    // (There can be at-most one such prime factor) 
    if (n > 1) 
        result -= result / n; 
    return result; 
} 
ll cc(ll n) 
{ 
    // Modulus operator are expensive 
    // on most of the computers. 
    // n & 3 will be equivalent to n % 4 
    // n % 4 
    switch (n & 3) { 
  
    // If n is a multiple of 4 
    case 0: 
        return n; 
  
    // If n % 4 gives remainder 1 
    case 1: 
        return 1; 
  
    // If n % 4 gives remainder 2 
    case 2: 
        return n + 1; 
  
    // If n % 4 gives remainder 3 
    case 3: 
        return 0; 
    } 
} 
ll pp(string s)
{
    reverse(s.begin(),s.end());
    int res=0;
    for(int i=0;i<s.length();i++)
    res+=(s[i]-'0')*pow(10,i);
    return res;
}
bool check(ll aa[],ll bb[],ll n)
{
    for(ll i=0;i<n;i++)
    if(aa[i]!=bb[i])
    return true;
    
    return false;
    
}
ll maxProductSubarrayOfSizeK(ll A[], ll n, ll k) 
{ 
    // sorting given input array 
    sort(A, A + n); 
  
    // variable to store final product of all element 
    // of sub-sequence of size k 
    ll product = 1LL; 
  
    // CASE I 
    // If max element is 0 and 
    // k is odd then max product will be 0 
    if (A[n - 1] == 0 && (k & 1)) 
        return 0LL; 
  
    // CASE II 
    // If all elements are negative and 
    // k is odd then max product will be 
    // product of rightmost-subarray of size k 
    if (A[n - 1] <= 0 && (k & 1)) { 
        for (int i = n - 1; i >= n - k; i--) 
            product =(product%MOD* A[i]%MOD)%MOD; 
        return product%MOD; 
    } 
  
    // else 
    // i is current left pointer index 
    int i = 0; 
  
    // j is current right pointer index 
    int j = n - 1; 
  
    // CASE III 
    // if k is odd and rightmost element in 
    // sorted array is positive then it 
    // must come in subsequence 
    // Multiplying A[j] with product and 
    // correspondingly changing j 
    if (k & 1) { 
        product =(product%MOD* A[j]%MOD)%MOD; 
        j--; 
        k--; 
    } 
  
    // CASE IV 
    // Now k is even 
    // Now we deal with pairs 
    // Each time a pair is multiplied to product 
    // ie.. two elements are added to subsequence each time 
    // Effectively k becomes half 
    // Hence, k >>= 1 means k /= 2 
    k >>= 1; 
  
    // Now finding k corresponding pairs 
    // to get maximum possible value of product 
    for (int itr = 0; itr < k; itr++) { 
  
        // product from left pointers 
        ll left_product = (A[i]%MOD * A[i + 1]%MOD)%MOD; 
  
        // product from right pointers 
        ll right_product = (A[j]%MOD * A[j - 1]%MOD)%MOD; 
  
        // Taking the max product from two choices 
        // Correspondingly changing the pointer's position 
        if (left_product > right_product) { 
            product =(product%MOD* left_product%MOD)%MOD; 
            i += 2; 
        } 
        else { 
            product =(product%MOD* right_product%MOD)%MOD; 
            j -= 2; 
        } 
    } 
  
    // Finally return product 
    return product%MOD; 
} 
void solve()
{
//comb(2001,2001);
std::ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
ll t;
t=1;
//cin>>t;

 
while(t--)
{
    map<ll,ll>mp;
    FOR(i,1,105)
    FOR(j,1,105)
    FOR(k,1,105)
    mp[i*i+j*j+k*k+i*j+j*k+k*i]++;
    ll n;
    cin>>n;
    FOR(i,1,n+1)
    cout<<mp[i]<<endl;
  
}
}





int main(){
    std::ios::sync_with_stdio(0);
    cin.tie(NULL);
    cout.tie(NULL);
    
    solve();
    
}












Measured memory_bytes: 6308