stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int main() {



    string A,B,X;



    A="ABC";

    B="ARC";



    cin>>X;



    if( X == A ){



        cout << B << endl;



    }else{

        cout << A << endl;

    }

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

 

int main() {

	char n[4];

	scanf("%s", n);

	if(n[1] == 'B'){

		puts("ARC");		

	}else if(n[1] == 'R'){

		puts("ABC");

	}

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



int main()

{

  string s; cin >> s;

  if(s == "ABC")

  	cout << "ARC" << endl;

  else cout << "ABC" << endl;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

 

int main() {

	char n[4];

	scanf("%s", n);

	if(n[1] == 'B'){

		puts("ARC");		

	}else if(n[1] == 'R'){

		puts("ABC");

	}

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;



main()

{

    string s;



    cin >> s;



    if(s == "ABC")

         cout <<"ARC";

    else

        cout <<"ABC";

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

 

int main() {

	char n[4];

	scanf("%s", n);

	if(n[1] == 'B'){

		puts("ARC");		

	}else if(n[1] == 'R'){

		puts("ABC");

	}

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <cstdio>

#include <algorithm>

#include <vector>

#include <set>

#include <queue>

#include <algorithm>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <iostream>

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef unsigned long long ull;

 

#define pb push_back

#define mk make_pair

#define f0(i,b) for(int i=0;i<(b);i++)

#define f1(i,b) for(int i=1;i<=(b);i++)

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

#define sf(a) scanf("%d",&a);

#define sfl(a) scanf("%lld",&a);

#define pf(a) printf("%d\n",a);

#define pfl(a) printf("%lld\n",a);

#define TEST int test; cin >> test;while(test--)

#define ii pair<int,int>

#define iil pair<ll,ll>

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

#define INF 2147483647

 

 

int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};

int dy8[] = {1,-1, 1, -1, 0, 0, -1, 1};

int dx4[] = {0, 0, 1, -1};

int dy4[] = {1, -1, 0, 0};

const double pi = acos(-1.0);

 

 

void solve()

{

   string s;

   cin >> s;

   if(s =="ABC") cout << "ARC" <<endl;

   else cout <<"ABC" <<endl;

}

 

int main()

{

    ios_base::sync_with_stdio(0);

    cin.tie(NULL);

    cout.tie(NULL);

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

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

    //TEST

    solve();

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

 

int main() {

	char n[4];

	scanf("%s", n);

	if(n[1] == 'B'){

		puts("ARC");		

	}else if(n[1] == 'R'){

		puts("ABC");

	}

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

int main(){

	string s;

	cin>>s;

	if(s=="ABC")

	cout<<"ARC"<<endl;

	else

	cout<<"ABC"<<endl; 



} 

// Optimized solution to the same problem (faster):
#include <stdio.h>

 

int main() {

	char n[4];

	scanf("%s", n);

	if(n[1] == 'B'){

		puts("ARC");		

	}else if(n[1] == 'R'){

		puts("ABC");

	}

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

#define pb push_back

#define ff first;

#define ss second;

#define ii pair<int,int>

#define vi vector<int>

#define vii vector<ii>

#define lli long long int

#define INF 1000000000

#define endl '\n'

const double pi = 3.141592653589793238460;

typedef std::complex<double> Complex;

typedef std::valarray<Complex> CArray;

using namespace std;

	

int main(){

	ios::sync_with_stdio(0);

	cin.tie(0);

	string n;

	cin >> n;

	if(n=="ABC"){

		cout << "ARC" << endl;

	}

	else{

		cout << "ABC" << endl;

	}

	

	

	return 0;

}




// Optimized solution to the same problem (faster):
#include <stdio.h>

 

int main() {

	char n[4];

	scanf("%s", n);

	if(n[1] == 'B'){

		puts("ARC");		

	}else if(n[1] == 'R'){

		puts("ABC");

	}

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main()

{

    string str;

    while(cin>>str)

    {

        if(str=="ABC")

        {

            cout<<"ARC"<<endl;

        }

        else if(str=="ARC")

        {

            cout<<"ABC"<<endl;

        }

    }

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

 

int main() {

	char n[4];

	scanf("%s", n);

	if(n[1] == 'B'){

		puts("ARC");		

	}else if(n[1] == 'R'){

		puts("ABC");

	}

	

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 0x3f3f3f3f

const int N=1e5+5;

char s[10];

int main()

{

    ios::sync_with_stdio(false);

    scanf("%s",s);

    if(s[1]=='B') printf("ARC\n");

    else if(s[1]=='R') printf("ABC\n");

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>





int main(){

	char stg[5];

	scanf("%s", stg);

	

	if(stg[1] == 'B'){

		printf("ARC");

	}

	else if(stg[1] == 'R'){

		printf("ABC");

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<cstring>

using namespace std;

int main()

{

	string s;

	cin>>s;

	if(s[1]=='B')

	cout<<"ARC";

	else 

	cout<<"ABC";

	return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>





int main(){

	char stg[5];

	scanf("%s", stg);

	

	if(stg[1] == 'B'){

		printf("ARC");

	}

	else if(stg[1] == 'R'){

		printf("ABC");

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<string>

using namespace std;

int main()

{

	string a;

	while(cin>>a)

	{

		if(a=="ABC")

		{

			cout<<"ARC"<<endl;

		}

		else

		  cout<<"ABC"<<endl;

	}

}

// Optimized solution to the same problem (faster):
#include <stdio.h>





int main(){

	char stg[5];

	scanf("%s", stg);

	

	if(stg[1] == 'B'){

		printf("ARC");

	}

	else if(stg[1] == 'R'){

		printf("ABC");

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

int main()

{

    char a,b,c;

    cin >> a >> b >> c;

    if(b=='B')

        cout << "ARC" << endl;

    else if(b=='R')

        cout << "ABC" << endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>





int main(){

	char stg[5];

	scanf("%s", stg);

	

	if(stg[1] == 'B'){

		printf("ARC");

	}

	else if(stg[1] == 'R'){

		printf("ABC");

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<string.h>

using namespace std;

int main()

{

    string s;

    

    cin >> s;

    

    if(s=="ABC")

        cout << "ARC" <<endl;

    else if(s=="ARC")

        cout << "ABC" <<endl;

    else

        return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>





int main(){

	char stg[5];

	scanf("%s", stg);

	

	if(stg[1] == 'B'){

		printf("ARC");

	}

	else if(stg[1] == 'R'){

		printf("ABC");

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main()

{

    string S;

    cin >> S;

    if(S=="ABC")

    {

        cout << "ARC";

    }

    else

    {

        cout << "ABC";

    }

    return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>





int main(){

	char stg[5];

	scanf("%s", stg);

	

	if(stg[1] == 'B'){

		printf("ARC");

	}

	else if(stg[1] == 'R'){

		printf("ABC");

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>





int main() {

    std::string t;

    std::cin >> t;

    if (t == "ARC") std::cout << "ABC";

    else std::cout << "ARC";

    return 0;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>





int main(){

	char stg[5];

	scanf("%s", stg);

	

	if(stg[1] == 'B'){

		printf("ARC");

	}

	else if(stg[1] == 'R'){

		printf("ABC");

	}

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

	}



}

// Fastest known solution for this problem:
// Original C++ solution (slower):
/*

*         ****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;

}


// Optimized solution to the same problem (faster):
#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;

	}



}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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";

	}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;



}


// Optimized solution to the same problem (faster):
#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;

                }

            }

        }

    }

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

                }

            }

        }

    }

}


// Optimized solution to the same problem (faster):
#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;

                }

            }

        }

    }

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

    }



}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem: