stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.313693644275054x):
#include <bits/stdc++.h>



using namespace std;





int countt(int i,int j,int u){

    if (i==j && i==u)

        return 1;

    if (i!=j && i!=u && j!=u)

        return 6;

    return 3;

}



int solve(int ind){

    int ans=0;

    for (int i=1;i*i<=ind;i++){

        for (int j=i;j*j<=ind;j++){

            for (int u=j;u*u<=ind;u++){

                if (i*i+j*j+u*u+i*j+i*u+j*u==ind)

                    ans+=countt(i,j,u);

            }

        }

    }

    return ans;

}



int main()

{

    int n;

    cin>>n;

    for (int i=1;i<=n;i++){

        cout<<solve(i)<<"\n";

    }





    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.091236248343221x):
#include<bits/stdc++.h>

using namespace std;

bool result(int x, int y, int z, int e){

	return ((x*x+z*z+y*y+x*y+y*z+z*x) <= e);

}

int main()

{

	int n, x, y, z, c = 0;

	cin>>n;

	for(int e = 1; e <= n; e++){

		c = 0;

		for( x = 1; x < int(sqrt(e));x++){

			for( y = 1; y < int(sqrt(e)); y++){

				for( z = 1; z < int(sqrt(e)); z++){

					 if((x*x+z*z+y*y+x*y+y*z+z*x) == e)

						 ++c;

					 else if((x*x+z*z+y*y+x*y+y*z+z*x) > e){

						 break;

					 }

				}

			}

		}

		cout<<c<<endl;

	}

	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.268400472266421x):
#include <bits/stdc++.h>

using namespace std;



int main()

{

    ios::sync_with_stdio(0);

    cin.tie(0); cout.tie(0);

    int n; cin >> n;

    for (int i = 1; i <= n; i++)

    {

        int cnt = 0;

        for (int x = 1; x*x <= i; x++)

        {

            for (int y = 1; y * y <= i; y++)

            {

                int b = x + y, c = i - x*x - y*y - x*y;

                if(c > 0)

                {

                    double z = (-b + sqrt(b * b + 4 * c)) / 2;

                    if (ceil(z) == floor(z)) cnt++;

                }

            }

        }

        cout << cnt << '\n';

    }

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.569817438311822x):
#include <iostream>

#include<vector>

#include<map>

#include<set>

#include<string>

#include<algorithm>

#include<math.h>

#include<bits/stdc++.h>

#include<cmath>

#include<iomanip>

using namespace std;



const double PI  =3.141592653589793238463;

#define pb push_back

#define pf push_front

#define sz(v)  ((int)(v).size());

#define all(v) ((v).begin()),((v).end())

typedef unsigned long long ull;

typedef long long ll;



typedef vector<int> vi;

typedef pair<int,int> pi;

//2 7 3 4 9



void printVec(vi v1)

{

    for(int i=0; i<v1.size(); i++)

        cout<<v1[i]<<" ";

    cout<<endl;

}

int main()

{

    ios::sync_with_stdio(false);

    cout.tie(NULL);

    cin.tie(NULL);





 ll n;cin>>n;

 map<ll,ll>MAP;

 ll new_n=sqrt(n);



for(ll x=1;x<=new_n;x++){

    for(ll y=1;y<=new_n;y++){

        for(ll z=1;z<=new_n;z++){

    ll v=(x*x)+(y*y)+(z*z)+(x*y)+(y*z)+(x*z);

    if(v>n){

        break;

    }

    MAP[v]++;



}

}

}



for(int i=1;i<=n;i++){

    cout<<MAP[i]<<endl;

}

    return 0;



}
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.904884208353958x):
/*

*         ****FOX****

*/

#include <iostream>

#include <string>

#include <algorithm>

#include <stack>

#include <queue>

#include <vector>

#include <map>

#include <set>

#include <sstream>

#include <iomanip>

#include <cmath>

#include <limits>

//freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);

#include <utility>

#include <list>

#include <cstdio>

#include<forward_list>

#include<algorithm>

#include<string>

#define Omar_Hafez ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define pi 3.1415926536

#define ll long long

#define ull unsigned long long

#define lli long long int

using namespace std;

int main()

{

    Omar_Hafez

   int n; cin >> n;

    vector<int> v(n,0); 

    for (int i = 1; i < 300; i++)

    {

        for (int j = 1; j < 300; j++)

        {

            for (int z = 1; z < 300; z++)

            {

                int res = (i * i) + (j * j) + (z * z) + (i * j) + (j * z) + (i * z);  

                if (res <= n)  v[--res]++;

                else break;

            }

        }

    }

    for (int i = 0; i< v.size(); i++) cout << v[i] << "\n";

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.863340430776961x):
#include <iostream>

#include <bits/stdc++.h>

using namespace std;



int main()

{

    int n;

    cin>>n;

    for (int k=1;k<=n;k++){

            int cnt=0;

    for (int i=1;i*i<=k;i++)

    {

        for (int j=1;j*j<=k;j++)

        {

            int x=i;

            int y=j;

            double c = (k-(x*x+y*y+x*y));

            c*=-1;

            int b = y+x;

            int z = max ( (-1*b+sqrt(b*b-4*c))/2 , (-1*b-sqrt(b*b-4*c))/2 );

            if ((x*x+y*y+z*z+x*z+x*y+y*z)==k&&z>0)

                cnt++;

        }

    }

    cout<<cnt<<endl;

    }

    return 0;

}
// Slower C++ solution:
/*

*         ****FOX****

*/

#include <iostream>

#include <string>

#include <algorithm>

#include <stack>

#include <queue>

#include <vector>

#include <map>

#include <set>

#include <sstream>

#include <iomanip>

#include <cmath>

#include <limits>

//freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);

#include <utility>

#include <list>

#include <cstdio>

#include<forward_list>

#include<algorithm>

#include<string>

#define Omar_Hafez ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define pi 3.1415926536

#define ll long long

#define ull unsigned long long

#define lli long long int

using namespace std;

int main()

{

    Omar_Hafez

   int n; cin >> n;

    vector<int> v(n,0); 

    for (int i = 1; i < 300; i++)

    {

        for (int j = 1; j < 300; j++)

        {

            for (int z = 1; z < 300; z++)

            {

                int res = (i * i) + (j * j) + (z * z) + (i * j) + (j * z) + (i * z);  

                if (res <= n)  v[--res]++;

                else break;

            }

        }

    }

    for (int i = 0; i< v.size(); i++) cout << v[i] << "\n";

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 0.9856986459365491x):
#include <iostream>

#include <bits/stdc++.h>

using namespace std;



int main()

{

    int n;

    cin>>n;

    for (int k=1;k<=n;k++){

            int cnt=0;

    for (int i=1;i*i<=k;i++)

    {

        for (int j=1;j*j<=k;j++)

        {

            int x=i;

            int y=j;

            double c = (k-(x*x+y*y+x*y));

            c*=-1;

            int b = y+x;

            int z = max ( (-1*b+sqrt(b*b-4*c))/2 , (-1*b-sqrt(b*b-4*c))/2 );

            if ((x*x+y*y+z*z+x*z+x*y+y*z)==k&&z>0)

                cnt++;

        }

    }

    cout<<cnt<<endl;

    }

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.647045488508751x):
#include<iostream>

#include<vector>

int num[10001];

using namespace std;

int main()

{

	int n; cin >> n;

	for (int i = 1; i <= 100; i++)

	{

		for (int j = 1; j <= 100; j++)

		{

			for (int k = 1; k <= 100; k++)

			{

				int x = i * i + k * k + j * j + i * j + i * k + j * k;

				if (x > n)

					break;

				num[x]++;

			}

		}

	}

	for (int i = 1; i <= n; i++)

	{

		cout << num[i] << endl;

	}



}
// Slower C++ solution:
/*

*         ****FOX****

*/

#include <iostream>

#include <string>

#include <algorithm>

#include <stack>

#include <queue>

#include <vector>

#include <map>

#include <set>

#include <sstream>

#include <iomanip>

#include <cmath>

#include <limits>

//freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);

#include <utility>

#include <list>

#include <cstdio>

#include<forward_list>

#include<algorithm>

#include<string>

#define Omar_Hafez ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define pi 3.1415926536

#define ll long long

#define ull unsigned long long

#define lli long long int

using namespace std;

int main()

{

    Omar_Hafez

   int n; cin >> n;

    vector<int> v(n,0); 

    for (int i = 1; i < 300; i++)

    {

        for (int j = 1; j < 300; j++)

        {

            for (int z = 1; z < 300; z++)

            {

                int res = (i * i) + (j * j) + (z * z) + (i * j) + (j * z) + (i * z);  

                if (res <= n)  v[--res]++;

                else break;

            }

        }

    }

    for (int i = 0; i< v.size(); i++) cout << v[i] << "\n";

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.2554873884544044x):
#include<iostream>

#include<vector>

int num[10001];

using namespace std;

int main()

{

	int n; cin >> n;

	for (int i = 1; i <= 100; i++)

	{

		for (int j = 1; j <= 100; j++)

		{

			for (int k = 1; k <= 100; k++)

			{

				int x = i * i + k * k + j * j + i * j + i * k + j * k;

				if (x > n)

					break;

				num[x]++;

			}

		}

	}

	for (int i = 1; i <= n; i++)

	{

		cout << num[i] << endl;

	}



}
// Slower C++ solution:
#include <iostream>

#include <math.h>

#include <vector>

#include <string>

using namespace std;

int main() {

	int N = 0;

	scanf("%d", &N);

	vector<long>v (N+1,0);



	/*

	for (int x = 1; x < 100; x++) {

		for (int y = 1; y < 100; y++) {

			for (int z = 1; z < 100; z++) {

				if ((x * x + y * y + z * z + x * y + x * z + z * y) != 0 && ((x * x + y * y + z * z + x * y + x * z + z * y) < v.size())) {

					v[(x * x + y * y + z * z + x * y + x * z + z * y) - 1]++;

				}

				

			}

			

		}

		

	}*/



	for (int i = 1; i < 100; i++) {

		for (int w = 1; w < 100; w++) {

			for (int y = 1; y < 100; y++) {

				if (((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w)) <= v.size()) {

					v[((i * i) + (w * w) + (y * y) + (i * w) + (i * y) + (y * w))]++;



				}



			}



		}

	}

	

	for (int i = 1; i <= N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		printf("\n");

	}

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.3116756265268315x):
#include <bits/stdc++.h>

using namespace std;

int main()

{

	int n;

	cin>>n;

	for (int i=1;i<=n;i++)

	{

		int ans=0;

		for (int x=1;x*x<=i;x++)

		{

			for (int y=x;y*y<=i;y++)

			{

				for (int z=y;z*z<=i;z++)

				{

					if (x*x+y*y+z*z+x*y+y*z+z*x==i)

					{

						if (x!=y&&x!=z&&y!=z)ans+=6;

						else if (x!=y&&x!=z&&y==z||x!=y&&y!=z&&x==z||x!=z&&y!=z&&x==y)ans+=3;

						else ans++;

					}

				}

			}

		}

		cout<<ans<<"\n";

	}

}
// Slower C++ solution:
/*

*         ****FOX****

*/

#include <iostream>

#include <string>

#include <algorithm>

#include <stack>

#include <queue>

#include <vector>

#include <map>

#include <set>

#include <sstream>

#include <iomanip>

#include <cmath>

#include <limits>

//freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);

#include <utility>

#include <list>

#include <cstdio>

#include<forward_list>

#include<algorithm>

#include<string>

#define Omar_Hafez ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define pi 3.1415926536

#define ll long long

#define ull unsigned long long

#define lli long long int

using namespace std;

int main()

{

    Omar_Hafez

   int n; cin >> n;

    vector<int> v(n,0); 

    for (int i = 1; i < 300; i++)

    {

        for (int j = 1; j < 300; j++)

        {

            for (int z = 1; z < 300; z++)

            {

                int res = (i * i) + (j * j) + (z * z) + (i * j) + (j * z) + (i * z);  

                if (res <= n)  v[--res]++;

                else break;

            }

        }

    }

    for (int i = 0; i< v.size(); i++) cout << v[i] << "\n";

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.1400370510476836x):
#include <bits/stdc++.h>

using namespace std;

int main()

{

	int n;

	cin>>n;

	for (int i=1;i<=n;i++)

	{

		int ans=0;

		for (int x=1;x*x<=i;x++)

		{

			for (int y=x;y*y<=i;y++)

			{

				for (int z=y;z*z<=i;z++)

				{

					if (x*x+y*y+z*z+x*y+y*z+z*x==i)

					{

						if (x!=y&&x!=z&&y!=z)ans+=6;

						else if (x!=y&&x!=z&&y==z||x!=y&&y!=z&&x==z||x!=z&&y!=z&&x==y)ans+=3;

						else ans++;

					}

				}

			}

		}

		cout<<ans<<"\n";

	}

}
// Slower C++ solution:
#include <algorithm>

#include <cmath>

#include <cstring>  // memset()

#include <iostream>

#include <map>

#include <set>

#include <string>

#include <vector>



using namespace std;



#define ll long long

#define For(i, a, b) for (int i = (int)(a), sz = (int)(b); i < sz; i++)

#define rFor(i, a, b) for (int i = (int)(a); i >= (int)(b); i--)

#define all(v) (v).begin(), (v).end()

#define rall(v) (v).rbegin(), (v).rend()

#define fill(a, b) memset(a, b, sizeof(a))

#define IO ios_base::sync_with_stdio(0), cin.tie(0)



const int MAX = 2e2 + 5;



int main() {

    IO;

    int n;

    cin >> n;

    vector<int> v(n + 1);

    For(i, 1, 100) For(j, 1, 100) For(k, 1, 100) {

        int a = i * i + j * j + k * k + i * j + j * k + i * k;

        if (a <= n)

            v[a]++;

    }

    For(i, 1, n + 1) printf("%d\n", v[i]);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.0808678691997504x):
#include <bits/stdc++.h>

using namespace std;

int main()

{

	int n;

	cin>>n;

	for (int i=1;i<=n;i++)

	{

		int ans=0;

		for (int x=1;x*x<=i;x++)

		{

			for (int y=x;y*y<=i;y++)

			{

				for (int z=y;z*z<=i;z++)

				{

					if (x*x+y*y+z*z+x*y+y*z+z*x==i)

					{

						if (x!=y&&x!=z&&y!=z)ans+=6;

						else if (x!=y&&x!=z&&y==z||x!=y&&y!=z&&x==z||x!=z&&y!=z&&x==y)ans+=3;

						else ans++;

					}

				}

			}

		}

		cout<<ans<<"\n";

	}

}
// Slower C++ solution:
#include <iostream>

#include <bits/stdc++.h>

using namespace std;

#define SZ(c) int(c.size())

#define pb push_back

#define loop(i,start,n)  for(int i=start;i<n;i++)

#define rloop(i,start,n)  for(int i=start;i>n;i--)



using ll = long long;

using vi = vector<int>;

using vll = vector<ll>;

using vvi = vector<vi>;

using vs = vector<string>;

const ll inf = 2e9+3;



void solve(){

    int tc=1 ;

    //cin >> tc;

    while(tc--) {

        ll n; cin >> n;

        vll v(n+2,0);

        loop(x,1,101){

            loop(y,1,101){

                loop(z,1,101){

                    ll ac = x*x + y*y + z*z + x*y + y*z + z*x;

                    if(ac <= n) v[ac]++;

                }

            }

        }

        loop(i,1,n+1)

            cout << v[i] << "\n";

    }

}



int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    solve();

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.557868164396886x):
/*

*         ****FOX****

*/

#include <iostream>

#include <string>

#include <algorithm>

#include <stack>

#include <queue>

#include <vector>

#include <map>

#include <set>

#include <sstream>

#include <iomanip>

#include <cmath>

#include <limits>

//freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout);

#include <utility>

#include <list>

#include <cstdio>

#include<forward_list>

#include<algorithm>

#include<string>

#define Omar_Hafez ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define pi 3.1415926536

#define ll long long

#define ull unsigned long long

#define lli long long int

using namespace std;

int main()

{

    Omar_Hafez

   int n; cin >> n;

    vector<int> v(n,0); 

    for (int i = 1; i < n; i++)

    {

        for (int j = 1; j < n; j++)

        {

            for (int z = 1; z < n; z++)

            {

                int res = (i * i) + (j * j) + (z * z) + (i * j) + (j * z) + (i * z);  

                if (res <= n)  v[--res]++;

                else break;

            }

        }

    }

    for (int i = 0; i< v.size(); i++) cout << v[i] << "\n";

    return 0;

}