stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>



using namespace std;



int main(){

	int a, b, c;

	cin >> a >> b >> c;

	if (a + b + c >= 22){

		cout << "bust";

	}else {

	cout << "win";

	}

	

	return 0;

}

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

int main(){

	int A1;

	int A2;

	int A3;

	scanf("%d %d %d",&A1,&A2,&A3);

//	printf("%d",A1+A2+A3);

	if(A1+A2+A3>=22){

		printf("bust\n");

	}

	else if(A1+A2+A3){

		printf("win\n");

	}

	

	return 0;

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



using namespace std;



int main()

{ int i,x,u;







     cin>>i >>x>>u;

     if(i+x+u>=22)

        cout<<"bust";

     else

        cout<<"win";

    return 0;

}


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

int main(){

	int A1;

	int A2;

	int A3;

	scanf("%d %d %d",&A1,&A2,&A3);

//	printf("%d",A1+A2+A3);

	if(A1+A2+A3>=22){

		printf("bust\n");

	}

	else if(A1+A2+A3){

		printf("win\n");

	}

	

	return 0;

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

#include <iomanip>

#include <stdio.h>

#include <math.h>

#include <string>

#include <cstring>

#include <bits/stdc++.h>

#include <search.h>

#include <algorithm>

#include <vector>

#include <deque>

#include <set>

#include<stack>

#include <utility>

using namespace std;

int main()

{

int a1,a2,a3;

cin>>a1>>a2>>a3;

if(a1+a2+a3 >= 22) cout<<"bust";

else cout<<"win";

return 0;

}


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

int main(){

	int A1;

	int A2;

	int A3;

	scanf("%d %d %d",&A1,&A2,&A3);

//	printf("%d",A1+A2+A3);

	if(A1+A2+A3>=22){

		printf("bust\n");

	}

	else if(A1+A2+A3){

		printf("win\n");

	}

	

	return 0;

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

using namespace std;



int main() {

	int b,c,d;

	cin>>b>>c>>d;

	if(b+c+d>=22)

	cout<<"bust";

	else

	cout<<"win";

	return 0;

}

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

int main(){

	int A1;

	int A2;

	int A3;

	scanf("%d %d %d",&A1,&A2,&A3);

//	printf("%d",A1+A2+A3);

	if(A1+A2+A3>=22){

		printf("bust\n");

	}

	else if(A1+A2+A3){

		printf("win\n");

	}

	

	return 0;

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

using namespace std;



int main() 

{

  int a,b,c;

  cin>>a>>b>>c;

  if(a+b+c>=22)

  {

    

    cout<<"bust";

  }

  else{

    cout<<"win";

  }

}

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

int main(){

	int A1;

	int A2;

	int A3;

	scanf("%d %d %d",&A1,&A2,&A3);

//	printf("%d",A1+A2+A3);

	if(A1+A2+A3>=22){

		printf("bust\n");

	}

	else if(A1+A2+A3){

		printf("win\n");

	}

	

	return 0;

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



using namespace std;



int main(){

	int a, b, c;

	cin >> a >> b >> c;

	if (a + b + c >= 22){

		cout << "bust";

	}else {

	cout << "win";

	}

	

	return 0;

}

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



int main()

{

  int a, b, c;

  scanf("%d %d %d", &a, &b, &c);

  if (a + b + c >= 22){

  printf("bust\n");}

  

  else {

  printf("win\n");}

  return 0;

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



using namespace std;



int main()

{ int i,x,u;







     cin>>i >>x>>u;

     if(i+x+u>=22)

        cout<<"bust";

     else

        cout<<"win";

    return 0;

}


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



int main()

{

  int a, b, c;

  scanf("%d %d %d", &a, &b, &c);

  if (a + b + c >= 22){

  printf("bust\n");}

  

  else {

  printf("win\n");}

  return 0;

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

#include <iomanip>

#include <stdio.h>

#include <math.h>

#include <string>

#include <cstring>

#include <bits/stdc++.h>

#include <search.h>

#include <algorithm>

#include <vector>

#include <deque>

#include <set>

#include<stack>

#include <utility>

using namespace std;

int main()

{

int a1,a2,a3;

cin>>a1>>a2>>a3;

if(a1+a2+a3 >= 22) cout<<"bust";

else cout<<"win";

return 0;

}


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



int main()

{

  int a, b, c;

  scanf("%d %d %d", &a, &b, &c);

  if (a + b + c >= 22){

  printf("bust\n");}

  

  else {

  printf("win\n");}

  return 0;

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

using namespace std;



int main() {

	int b,c,d;

	cin>>b>>c>>d;

	if(b+c+d>=22)

	cout<<"bust";

	else

	cout<<"win";

	return 0;

}

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



int main()

{

  int a, b, c;

  scanf("%d %d %d", &a, &b, &c);

  if (a + b + c >= 22){

  printf("bust\n");}

  

  else {

  printf("win\n");}

  return 0;

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

using namespace std;



int main() 

{

  int a,b,c;

  cin>>a>>b>>c;

  if(a+b+c>=22)

  {

    

    cout<<"bust";

  }

  else{

    cout<<"win";

  }

}

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



int main()

{

  int a, b, c;

  scanf("%d %d %d", &a, &b, &c);

  if (a + b + c >= 22){

  printf("bust\n");}

  

  else {

  printf("win\n");}

  return 0;

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



using namespace std;



int main(){

	int a, b, c;

	cin >> a >> b >> c;

	if (a + b + c >= 22){

		cout << "bust";

	}else {

	cout << "win";

	}

	

	return 0;

}

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



int main () 

{

	int A;

	int B;

	int C;

	scanf("%d %d %d",&A,&B,&C);

	(A + B + C >=22) ? puts("bust") : puts("win");

	

	return 0;

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



using namespace std;



int main()

{ int i,x,u;







     cin>>i >>x>>u;

     if(i+x+u>=22)

        cout<<"bust";

     else

        cout<<"win";

    return 0;

}


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



int main () 

{

	int A;

	int B;

	int C;

	scanf("%d %d %d",&A,&B,&C);

	(A + B + C >=22) ? puts("bust") : puts("win");

	

	return 0;

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

#include <iomanip>

#include <stdio.h>

#include <math.h>

#include <string>

#include <cstring>

#include <bits/stdc++.h>

#include <search.h>

#include <algorithm>

#include <vector>

#include <deque>

#include <set>

#include<stack>

#include <utility>

using namespace std;

int main()

{

int a1,a2,a3;

cin>>a1>>a2>>a3;

if(a1+a2+a3 >= 22) cout<<"bust";

else cout<<"win";

return 0;

}


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



int main () 

{

	int A;

	int B;

	int C;

	scanf("%d %d %d",&A,&B,&C);

	(A + B + C >=22) ? puts("bust") : puts("win");

	

	return 0;

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

using namespace std;



int main() {

	int b,c,d;

	cin>>b>>c>>d;

	if(b+c+d>=22)

	cout<<"bust";

	else

	cout<<"win";

	return 0;

}

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



int main () 

{

	int A;

	int B;

	int C;

	scanf("%d %d %d",&A,&B,&C);

	(A + B + C >=22) ? puts("bust") : puts("win");

	

	return 0;

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

using namespace std;



int main() 

{

  int a,b,c;

  cin>>a>>b>>c;

  if(a+b+c>=22)

  {

    

    cout<<"bust";

  }

  else{

    cout<<"win";

  }

}

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



int main () 

{

	int A;

	int B;

	int C;

	scanf("%d %d %d",&A,&B,&C);

	(A + B + C >=22) ? puts("bust") : puts("win");

	

	return 0;

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



using namespace std;



int main(){

	int a, b, c;

	cin >> a >> b >> c;

	if (a + b + c >= 22){

		cout << "bust";

	}else {

	cout << "win";

	}

	

	return 0;

}

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



int main(){

int a1,a2,a3,score;

scanf("%d %d %d", &a1,&a2,&a3);

score=a1+a2+a3;

if (score>=22) {

printf("bust\n");

}

else {

printf("win\n");

}



return 0;

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



using namespace std;



int main()

{ int i,x,u;







     cin>>i >>x>>u;

     if(i+x+u>=22)

        cout<<"bust";

     else

        cout<<"win";

    return 0;

}


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



int main(){

int a1,a2,a3,score;

scanf("%d %d %d", &a1,&a2,&a3);

score=a1+a2+a3;

if (score>=22) {

printf("bust\n");

}

else {

printf("win\n");

}



return 0;

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

#include <iomanip>

#include <stdio.h>

#include <math.h>

#include <string>

#include <cstring>

#include <bits/stdc++.h>

#include <search.h>

#include <algorithm>

#include <vector>

#include <deque>

#include <set>

#include<stack>

#include <utility>

using namespace std;

int main()

{

int a1,a2,a3;

cin>>a1>>a2>>a3;

if(a1+a2+a3 >= 22) cout<<"bust";

else cout<<"win";

return 0;

}


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



int main(){

int a1,a2,a3,score;

scanf("%d %d %d", &a1,&a2,&a3);

score=a1+a2+a3;

if (score>=22) {

printf("bust\n");

}

else {

printf("win\n");

}



return 0;

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

using namespace std;



int main() {

	int b,c,d;

	cin>>b>>c>>d;

	if(b+c+d>=22)

	cout<<"bust";

	else

	cout<<"win";

	return 0;

}

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



int main(){

int a1,a2,a3,score;

scanf("%d %d %d", &a1,&a2,&a3);

score=a1+a2+a3;

if (score>=22) {

printf("bust\n");

}

else {

printf("win\n");

}



return 0;

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

using namespace std;



int main() 

{

  int a,b,c;

  cin>>a>>b>>c;

  if(a+b+c>=22)

  {

    

    cout<<"bust";

  }

  else{

    cout<<"win";

  }

}

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



int main(){

int a1,a2,a3,score;

scanf("%d %d %d", &a1,&a2,&a3);

score=a1+a2+a3;

if (score>=22) {

printf("bust\n");

}

else {

printf("win\n");

}



return 0;

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



using namespace std;



int main(){

	int a, b, c;

	cin >> a >> b >> c;

	if (a + b + c >= 22){

		cout << "bust";

	}else {

	cout << "win";

	}

	

	return 0;

}

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

int main()

{

	int A1;

	int A2;

	int A3;

	int hasil;

	scanf("%d", &A1);

	scanf("%d", &A2);

	scanf("%d", &A3);

	

	if( A1 + A2 + A3 >= 22){

		hasil = A1 + A2 + A3;

		printf("bust\n");

	}

	else {

		hasil = A1 + A2 + A3;

		printf("win\n");

	}

	return 0;

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



using namespace std;



int main()

{ int i,x,u;







     cin>>i >>x>>u;

     if(i+x+u>=22)

        cout<<"bust";

     else

        cout<<"win";

    return 0;

}


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

int main()

{

	int A1;

	int A2;

	int A3;

	int hasil;

	scanf("%d", &A1);

	scanf("%d", &A2);

	scanf("%d", &A3);

	

	if( A1 + A2 + A3 >= 22){

		hasil = A1 + A2 + A3;

		printf("bust\n");

	}

	else {

		hasil = A1 + A2 + A3;

		printf("win\n");

	}

	return 0;

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

#include <iomanip>

#include <stdio.h>

#include <math.h>

#include <string>

#include <cstring>

#include <bits/stdc++.h>

#include <search.h>

#include <algorithm>

#include <vector>

#include <deque>

#include <set>

#include<stack>

#include <utility>

using namespace std;

int main()

{

int a1,a2,a3;

cin>>a1>>a2>>a3;

if(a1+a2+a3 >= 22) cout<<"bust";

else cout<<"win";

return 0;

}


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

int main()

{

	int A1;

	int A2;

	int A3;

	int hasil;

	scanf("%d", &A1);

	scanf("%d", &A2);

	scanf("%d", &A3);

	

	if( A1 + A2 + A3 >= 22){

		hasil = A1 + A2 + A3;

		printf("bust\n");

	}

	else {

		hasil = A1 + A2 + A3;

		printf("win\n");

	}

	return 0;

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

using namespace std;



int main() {

	int b,c,d;

	cin>>b>>c>>d;

	if(b+c+d>=22)

	cout<<"bust";

	else

	cout<<"win";

	return 0;

}

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

int main()

{

	int A1;

	int A2;

	int A3;

	int hasil;

	scanf("%d", &A1);

	scanf("%d", &A2);

	scanf("%d", &A3);

	

	if( A1 + A2 + A3 >= 22){

		hasil = A1 + A2 + A3;

		printf("bust\n");

	}

	else {

		hasil = A1 + A2 + A3;

		printf("win\n");

	}

	return 0;

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

using namespace std;



int main() 

{

  int a,b,c;

  cin>>a>>b>>c;

  if(a+b+c>=22)

  {

    

    cout<<"bust";

  }

  else{

    cout<<"win";

  }

}

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

int main()

{

	int A1;

	int A2;

	int A3;

	int hasil;

	scanf("%d", &A1);

	scanf("%d", &A2);

	scanf("%d", &A3);

	

	if( A1 + A2 + A3 >= 22){

		hasil = A1 + A2 + A3;

		printf("bust\n");

	}

	else {

		hasil = A1 + A2 + A3;

		printf("win\n");

	}

	return 0;

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

#include <string>

#include <algorithm>

#include <vector>

#include <iomanip>

#include <cmath>

#include <stdio.h>

#include <queue>

#include <deque>

#include <cstdio>

#include <set>

#include <map>

#include <bitset>

#include <stack>

#include <cctype>

using namespace std;

int gcd(int a, int b)

{

	if (a % b == 0)

	{

		return(b);

	}

	else

	{

		return(gcd(b, a % b));

	}

}

int main(){

	int k;

	cin >> k;

	int ans = 0;

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

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

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

				ans += gcd(gcd(i, j), l);

			}

		

		}

	}

	cout << ans << endl;

	return 0;

}

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

#include <string>

#include <algorithm>

#include <vector>

#include <iomanip>

#include <cmath>

#include <stdio.h>

#include <queue>

#include <deque>

#include <cstdio>

#include <set>

#include <map>

#include <bitset>

#include <stack>

#include <cctype>

using namespace std;

long long e[100010];

int main() {

    long long n, k;

    cin >> k;

    n = 3;

    long long ans = 0;

    for (long long i = 1; i <= k; i++) {

        long long m = k / i;

        long long b = 0;

        for (long long j = 1; j * j <= i; j++) {

            if (i % j == 0) {

                b += e[j];

                if (j != i / j && j != 1) {

                    b += e[i / j];

                }

            }

        }

        if (i == 1) {

            b = 0;

        }

        long long n1 = n;

        long long ans1 = 1;

        while (n1 > 0) {

            if ((n1 & 1) == 1) {

                ans1 = ans1 * m % 1000000007;

            }

            m = m * m % 1000000007;

            n1 >>= 1;

        }

        ans += ans1 * (i - b) % 1000000007;

        ans %= 1000000007;

        e[i] = (i - b);

    }

    cout << ans << endl;

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

using namespace std;

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

using ll = long long;

using vi = vector<int>;

using vvi = vector<vi>;



int main(){

  int k;

  cin >> k;

  int ans = 0;

  for(int a=1; a<=k; a++)for(int b=1; b<=k; b++)for(int c=1; c<=k; c++){

    int mx = 0;

    mx = min(a, b);

    mx = min(mx, c);

    for(int i=mx; i>=1; i--){

      if(a%i==0 && b%i==0 & c%i==0){

        ans += i;

        break;

      }

    }

  }

  cout << ans << endl;

}


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

using namespace std;

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

using ll = long long;

using vi = vector<int>;

using vvi = vector<vi>;



int main(){

  int k;

  cin >> k;

  int ans = 0;

  for(int a=1; a<=k; a++)for(int b=1; b<=k; b++)for(int c=1; c<=k; c++){

    ans += gcd(a, gcd(b, c));

  }

  cout << ans << endl;

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

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

     

    using namespace std;  

    using ll = long long;

    using P = pair<int,int>; 

    

    int main() {

   

     int k;

     cin >> k;

     ll count = 0;

     for(int i = 1; i <= k; i++){//a

     	for(int j = 1; j <= k; j++){//b

     		for(int m = 1; m <= k; m++){//c

     			int a = i;

     			int b = j;

     			int c = m;

     			

     			int min = a;

     			if(min>=b)	min = b;

     			if(min>=c)	min = c;

     			

     			int go = 1;

     			

     			for(int h = 1; h <= min; h++){

     				if(a%h == 0 && b%h == 0 && c%h == 0) go = h;

     			}

     			count += go;

     		}

     	}

     }

     	cout << count <<'\n';

     

     return 0;

    }

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

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

     

    using namespace std;  

    using ll = long long;

    using P = pair<int,int>; 

    

    ll gcd(ll x,ll y){

    	if(y==0) return x;

    	else	 return gcd(y,x%y);

    }

    int main() {

    int k;

    cin >> k;

    ll sum = 0;

    

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

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

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

    			sum += gcd(gcd(a,b),c);

   		    }

    	

        }

    }

    

    cout << sum <<'\n';

     

     return 0;

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



using namespace std;



typedef vector< int > vi;

typedef vector< vi > vvi;

typedef pair< int,int > ii;

#define ll	long long

#define sz(a) int((a).size())

#define pb push_back

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

#define tr(c,i) for(typeof((c)).begin() i = (c).begin(); i != (c).end(); i++)

#define present(c,x) ((c).find(x) != (c).end())

#define cpresent(c,x) (find(all(c),x) != (c).end())

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



int gcd(int a, int b, int c) {

	return __gcd(a, __gcd(b, c)); 

}

int main() {	

	int k, sum = 0;

	cin>>k;

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

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

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

				sum += gcd(a, b, c);

			}

		}

	}

	cout<<sum;

	return 0;

}


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

 

using namespace std;

 

typedef vector< int > vi;

typedef vector< vi > vvi;

typedef pair< int,int > ii;

#define ll	long long

#define sz(a) int((a).size())

#define pb push_back

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

#define tr(c,i) for(typeof((c)).begin() i = (c).begin(); i != (c).end(); i++)

#define present(c,x) ((c).find(x) != (c).end())

#define cpresent(c,x) (find(all(c),x) != (c).end())

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

#define hell 1000000007

#define PI 3.141592653589793



int main() 

{	ios;

	int t = 1;

	//cin>>t;

	while (t--) {

		int n = 3, k;

		cin>>k;

		unsigned ll dp[k+1];

		dp[0] = 0;

		dp[k] = 1;

		for (int h = k-1; h >= 1; --h) {

			int base = k/h;

			dp[h] = int(pow(base, n) + 0.5);

			//cout<<h<<" "<<ans[h]<<"\n";

			for (int mul = 2; h*mul <= k; mul++) {

				dp[h] -= dp[h*mul];

			}

			//cout<<"after mul "<<ans[h]<<"\n";

		}

		//for (auto x : dp) cout<<x<<" ";

		unsigned ll sum = 0;

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

			sum += i*dp[i];

		}

		sum %= hell;

		cout<<sum;

		cout<<"\n";

	}

    return 0; 

} 

/*

look for out of bounds

look for integer overflow, long long vs int

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

using namespace std;



int main() {

  int N;

  cin >> N;

  long ans = 0;

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

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

      for (int k = 1; k <= N; k++) ans += gcd(gcd(i, j), k);

  cout << ans << "\n";

}

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

using namespace std;



int main() {

  int N;

  cin >> N;

  vector<int> V(N);

  for (int i = N; i > 0; i--) {

    V.at(i - 1) += (N / i) * (N / i) * (N / i);

    int j = i * 2;

    while (j <= N) V.at(i - 1) -= V.at(j - 1), j += i;

  }



  int ans = 0;

  for (int i = 0; i < N; i++) ans += V.at(i) * (i + 1);

  cout << ans << "\n";

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

#define FOR(i, a, n) for(ll i = (ll)a; i < (ll)n; i++)

#define FORR(i, n) for(ll i = (ll)n - 1LL; i >= 0LL; i--)

#define rep(i, n) FOR(i, 0, n)

#define ALL(x) (x).begin(), (x).end()

using namespace std;

using ll = long long;

template <typename T> using V = vector<T>;

constexpr int Mod = 998244353;

constexpr int mod = 1e9 + 7;

constexpr ll inf = 1LL << 60;

template <typename T> constexpr bool chmax(T &a, const T &b) {

    if(a >= b) return false;

    a = b;

    return true;

}

template <typename T> constexpr bool chmin(T &a, const T &b) {

    if(a <= b) return false;

    a = b;

    return true;

}



/*-------------------------------------------*/



int main() {

    cin.tie(0);

    ios::sync_with_stdio(0);



    int k;

    cin >> k;

    ll ans = 0;

    FOR(i, 1, k + 1)

    FOR(j, 1, k + 1) FOR(l, 1, k + 1) ans += __gcd(i, __gcd(j, l));



    cout << ans << endl;



    return 0;

}

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

#define FOR(i, a, n) for(ll i = (ll)a; i < (ll)n; i++)

#define FORR(i, n) for(ll i = (ll)n - 1LL; i >= 0LL; i--)

#define rep(i, n) FOR(i, 0, n)

#define ALL(x) (x).begin(), (x).end()

using namespace std;

using ll = long long;

template <typename T> using V = vector<T>;

constexpr int Mod = 998244353;

constexpr int mod = 1e9 + 7;

constexpr ll inf = 1LL << 60;

template <typename T> constexpr bool chmax(T &a, const T &b) {

    if(a >= b) return false;

    a = b;

    return true;

}

template <typename T> constexpr bool chmin(T &a, const T &b) {

    if(a <= b) return false;

    a = b;

    return true;

}



/*-------------------------------------------*/



int G[201][201];



int mygcd(int a, int b) {

    if(G[a][b]) return G[a][b];

    return G[a][b] = G[b][a] = __gcd(a, b);

}



int main() {

    cin.tie(0);

    ios::sync_with_stdio(0);



    int k;

    cin >> k;

    ll ans = 0;

    FOR(i, 1, k + 1)

    FOR(j, 1, k + 1) FOR(l, 1, k + 1) ans += mygcd(i, mygcd(j, l));



    cout << ans << endl;



    return 0;

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

using namespace std;



main()

{

int A,B,C,D, a[1000],b[1000],c[1000],n,aaa,k,i,r=0,rr=0,d1,dd=0,d2,d3,ck=0,m,j,aa,bb,cc;

//char cr[1000];

//scanf("%lld",&n);

//cin>>A>>B>>C>>D;

cin>>n;



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



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



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

                aa=i;

                bb=j;

                cc=k;





        int x,y,z;

   // cout<<a[i]<<b[i]<<c[i]<<endl;









    if((aa<bb)&&(aa<cc)){

        x=aa;

    }

    else if((bb<aa)&&(bb<cc)){

        x=bb;

    }

    else{

        x=cc;

    }

  vvv:  if((aa%x==0)&&(bb%x==0)&&(cc%x==0)){

            y=x;



        dd=dd+y;

        x=123456;

    }



   if(x!=123456){

    x=x-1;

   }

    if(x!=123456)goto vvv;







}



}}



  cout<<dd;

//printf("%lld",dd);



    return 0;

}

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

using namespace std;

int grt(int a,int b,int c)

{

    int p=__gcd(a,b);

    return __gcd(p,c);

}





int main()

{

    int p;

    cin>>p;

    long int sum=0;

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

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

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

                sum+=grt(i,j,k);

    cout<<sum;



    return 0;

}