stablegradients/pie-gem5-pairs huggingface dataset:
// 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.6681900970105974x):
/*

*         ****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 < 99; i++)

    {

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

        {

            for (int z = 1; z < 99; 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 <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.39535016707989x):
#include <iostream>

using namespace std;

int counter(int x, int y, int z) {

    if (x == y && x == z)

        return 1;

    if (x != y && x != z && y != z)

        return 6;

    return 3;

}



int the_sol(int ind) {

    int sum = 0;

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

        for (int y = x; y * y <= ind; y++) {

            for (int z = y; z * z <= ind; z++) {

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

                    sum += counter(x, y, z);

            }

        }

    }

    return sum;

}

int main() {

    int n;

    cin >> n;

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

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

    return 0;

}
// 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.8441179656344864x):
#include <iostream>

#include <bits/stdc++.h>



using namespace std;



int f(int x, int y, int z)

{

    return (x * x) + (y * y) + (z * z) + (x * y) + (y * z) + (z * x);

}



int main()

{

    int n;

    cin >> n;

    int arr[n];

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

        arr[i] = 0;

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

    {

        for (int y = 1; ((x * x) + (y * y) + (x * y)) <= n; y++)

        {

            for (int z = 1; f(x, y, z) <= n; z++)

            {

                int result = f(x, y, z);

                if (result <= n)

                    arr[result - 1]++;

            }

        }

    }

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

        cout << arr[i] << endl;

    return 0;

}
// 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.654885197054484x):
#pragma GCC optimize("O2")

#include<iostream>

using namespace std;

#define f(x,y,z) for(int x=y;x<z;++x)

int h, h1, h2, n, c, l, r, t, z;

int main() {

    ios_base::sync_with_stdio(false);cin.tie(0);

    cin >> n;

    f(i,1,n+1) {

        h = h1 = h2 = 0;

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

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

                z = y;

                while(x*x+y*y+z*z+x*y+y*z+z*x < i) ++z;

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

                    if(x == y || y == z || z == x) {

                        if(x == y && y == z && z == x) ++h2;

                        else ++h1;

                    } else ++h;

                }

            }

        }

        cout << h*6+h1*3+h2 << '\n';

    }

    // cout << c << '\n';

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define rep(i,n) for(int i=0; i<(n); i++)

#define rep2(i,x,n) for(int i=x; i<(n); i++)

#define all(n) begin(n),end(n)

struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;

const long long INF = numeric_limits<long long>::max();

int main(){

    int N;

    cin>>N;

    //愚直に探す

    //N<10000よりx<=y<=zとするとxは最高でも100



    int ans=0;



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

        ans=0;

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

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

                

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

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

                        if(x==y&&y==z){

                            ans++;

                        }else if(x!=y&&y==z){

                            ans+=3;

                        }else if(x==y&&y!=z){

                            ans+=3;

                        }else{

                            ans+=6;

                        }

                    }else if(x*x+y*y+z*z+x*y+y*z+z*x>i){

                        break;

                    }

                }

            }

        }

        cout << ans << endl;

    }

    return 0;

}

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

using namespace std;

#define rep(i,n) for(int i=0; i<(n); i++)

#define rep2(i,x,n) for(int i=x; i<(n); i++)

#define all(n) begin(n),end(n)

struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;

const long long INF = numeric_limits<long long>::max();

int main(){

    int N;

    cin>>N;

    //愚直に探す

    //N<10000よりx<=y<=zとするとxは最高でも100

    vector<int> ans(N+1);

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

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

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

                    int v=x*x+y*y+z*z+x*y+y*z+z*x;

                    if(v<=N){

                        ans[v]++;

                    }else{

                        break;

                    }

                }

            }

        }

    

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

        cout << ans[i] << endl;

    }

    return 0;

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

#include<vector>

#include<algorithm>

#include<map>

#include<queue>

#include<cmath>



using namespace std;

int helper(int N);

int main(){

    int n;

    cin >> n;

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

        cout << helper(N) << endl;

    }



    return 0;

}







int helper(int N){

    int cnt=0;



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

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

            if(x*x+y*y+x*y > N){continue;}

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

                if(x*x + y*y + z*z + x*y + y*z + z*x == N){

                    if(x == y && y == z){

                        cnt += 1;

                    }else if(x == y || y == z || z == x){

                        cnt += 3;

                    }else{

                        cnt += 6;

                    }

                }

            }

        }

    }

    return cnt;



}


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

#include<vector>

#include<algorithm>

#include<map>

#include<queue>

#include<cmath>



using namespace std;

int helper(int N);

int main(){

    int n;

    cin >> n;

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

        cout << helper(N) << endl;

    }



    return 0;

}







int helper(int N){

    int cnt=0;



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

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

            if(x*x+y*y+x*y > N){break;}

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

                if(x*x + y*y + z*z + x*y + y*z + z*x == N){

                    if(x == y && y == z){

                        cnt += 1;

                    }else if(x == y || y == z || z == x){

                        cnt += 3;

                    }else{

                        cnt += 6;

                    }

                }

            }

        }

    }

    return cnt;



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

#include<vector>

#include<algorithm>

#include<map>

#include<queue>

#include<cmath>



using namespace std;

int helper(int N);

int main(){

    int n;

    cin >> n;

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

        cout << helper(N) << endl;

    }



    return 0;

}







int helper(int N){

    int cnt=0;



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

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

            if(x*x+y*y+x*y > N){continue;}

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

                if(x*x + y*y + z*z + x*y + y*z + z*x == N){

                    if(x == y && y == z){

                        cnt += 1;

                    }else if(x == y || y == z || z == x){

                        cnt += 3;

                    }else{

                        cnt += 6;

                    }

                }

            }

        }

    }

    return cnt;



}


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

#include<vector>

#include<algorithm>

#include<map>

#include<queue>

#include<cmath>



using namespace std;

void helper(int N);

int p[10005];

int main(){

    int n;

    cin >> n;

    helper(n);

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

        cout << p[N] << endl;

    }



    return 0;

}







void helper(int N){

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

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

            if(x*x+y*y+x*y > N){break;}

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

                int ns = x*x + y*y + z*z + x*y + y*z + z*x;

                if(ns >= 10005){break;}

                if(x == y && y == z){

                    p[ns] += 1;

                }else if(x == y || y == z || z == x){

                    p[ns] += 3;

                }else{

                    p[ns] += 6;

                }

            }

        }

    }

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

#include<vector>

#include<algorithm>

#include<map>

#include<queue>

#include<cmath>



using namespace std;

void helper(void);

int p[10005];

int main(){

    int n;

    cin >> n;

    helper();

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

        cout << p[N] << endl;

    }



    return 0;

}







void helper(){

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

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

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

                int N = x*x + y*y + z*z + x*y + y*z + z*x;

                if(N >= 10005){break;}

                if(x == y && y == z){

                    p[N] += 1;

                }else if(x == y || y == z || z == x){

                    p[N] += 3;

                }else{

                    p[N] += 6;

                }

            }

        }

    }

}


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

#include<vector>

#include<algorithm>

#include<map>

#include<queue>

#include<cmath>



using namespace std;

void helper(int N);

int p[10005];

int main(){

    int n;

    cin >> n;

    helper(n);

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

        cout << p[N] << endl;

    }



    return 0;

}







void helper(int N){

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

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

            if(x*x+y*y+x*y > N){break;}

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

                int ns = x*x + y*y + z*z + x*y + y*z + z*x;

                if(ns >= 10005){break;}

                if(x == y && y == z){

                    p[ns] += 1;

                }else if(x == y || y == z || z == x){

                    p[ns] += 3;

                }else{

                    p[ns] += 6;

                }

            }

        }

    }

}
// 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 = 0; i < N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		//if (i != N - 1) {

		printf("\n");

	//}

	}

	

	return 0;

}

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

#include <map>

using namespace std;



int main()

{

	long long n, res;

	cin >> n;

	map<long long, long long>count;

	for (long long x = 1; x <= n; ++x)

	{

		for (long long y = 1; y <= n - x; ++y)

		{

			for (long long z = 1; z <= n - y; ++z)

			{

				res = x * x + y * y + z * z + x * y + y * z + z * x;

				if (res <= n)

				{

					count[res]++;

				}

				else break;

			}

		}

	}

	for (long long i = 1; i <= n; ++i) cout << count[i] << endl;

	ios::sync_with_stdio(false);

	cin.tie();

	cout.tie();

	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 = 0; i < N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		//if (i != N - 1) {

		printf("\n");

	//}

	}

	

	return 0;

}

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

using namespace std;

typedef long long ll;

typedef unsigned long long ull;



int main()

{

    int n;

    map<int,int>m;

    cin>>n;



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

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

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

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

                if(v>n)

                    break;

                

                m[v]++;

            }

        }

    }



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

        cout<<m[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 = 0; i < N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		//if (i != N - 1) {

		printf("\n");

	//}

	}

	

	return 0;

}

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

#include <cmath>

using namespace std;

int main(){

    int x,y,z,idx=0,sum;

    int formula = 0;

    int n;cin>>n;

    int start = 1;

    while(start <= n){

            int sqr = sqrt(start);

            sum = 0;

            for(x=1;x<=sqr;x++){

                for(y=1;y<=sqr;y++){

                    for(z=1;z<=sqr;z++){

                        formula = (x*x)+(y*y)+(z*z)+(x*y)+(y*z)+(z*x);

                        if(formula == start)

                            sum++;

                        else if(formula > start)

                            break;

                    }

                }

            }

            cout<<sum<<endl;

            start++;

    }

    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 = 0; i < N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		//if (i != N - 1) {

		printf("\n");

	//}

	}

	

	return 0;

}

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

using namespace std;

#include <bits/stdc++.h>

#include<cmath>

int operation(int x, int y, int z)

{

    int val = (x*x)+(y*y)+(z*z)+(x*y)+(y*z)+(x*z);

    return val;

}

int main()

{

    int n;

    cin >>n;

    int counter=0;

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

    {

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

        {

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

            {

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

                {

                    if(i == operation(x,y,z))

                    {

                        counter++;

                    }

                    else if(i < operation(x,y,z))

                        break;



                }

            }

        }



        cout<<counter<<endl;

        counter=0;

    }



    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 = 0; i < N; i++) {

		string str = to_string(v[i]);

		const char* l = str.c_str();

		printf(l);

		//if (i != N - 1) {

		printf("\n");

	//}

	}

	

	return 0;

}

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



using namespace std;



int main()

{

    int n;

    cin>>n;

    int arr[10001] = {0};

    int m =  min(n,99);

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

    {

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

        {

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

            {

                if(i*i+j*j+z*z+i*j+i*z+j*z <= 10000)

                    arr[i*i+j*j+z*z+i*j+i*z+j*z]++;

            }

        }

    }

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

    {

        cout<<arr[i]<<endl;

    }

    return 0;

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

using namespace std;

#include <bits/stdc++.h>

#include<cmath>

int operation(int x, int y, int z)

{

    int val = (x*x)+(y*y)+(z*z)+(x*y)+(y*z)+(x*z);

    return val;

}

int main()

{

    int n;

    cin >>n;

    int counter=0;

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

    {

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

        {

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

            {

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

                {

                    if(i == operation(x,y,z))

                    {

                        counter++;

                    }

                    else if(i < operation(x,y,z))

                        break;



                }

            }

        }



        cout<<counter<<endl;

        counter=0;

    }



    return 0;

}

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



using namespace std;



int main()

{

    int n;

    cin>>n;

    int arr[10001] = {0};

    int m =  min(n,99);

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

    {

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

        {

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

            {

                if(i*i+j*j+z*z+i*j+i*z+j*z <= 10000)

                    arr[i*i+j*j+z*z+i*j+i*z+j*z]++;

            }

        }

    }

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

    {

        cout<<arr[i]<<endl;

    }

    return 0;

}