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

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


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



int main(){

    int N;

    scanf("%d", &N);

    

    printf("%d\n", N*N*N);



    return 0;

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

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

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



int main(){

    int N;

    scanf("%d", &N);

    

    printf("%d\n", N*N*N);



    return 0;

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

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


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



int main(){

    int N;

    scanf("%d", &N);

    

    printf("%d\n", N*N*N);



    return 0;

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

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

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



int main(){

    int N;

    scanf("%d", &N);

    

    printf("%d\n", N*N*N);



    return 0;

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

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


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



int main(){

    int N;

    scanf("%d", &N);

    

    printf("%d\n", N*N*N);



    return 0;

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

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

using namespace std;

int main(){

int n;

cin >> n;

cout << n*n*n << endl;

return 0;

}

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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

#include<cmath>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<pow(n,3);



    return 0;

}

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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

using namespace std;







int main()

{

  int N;

  cin>>N;

int x =N*N*N;

cout<<x;



		return 0;

}


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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

#include <cmath>

using namespace std;



int main()

{

    int n;

    cin >> n;

    int x=pow(n,3);

    cout << x;

    return 0;

}


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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


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



int main() {

	int num;

	scanf("%d", &num);

	

	int result = num*num*num;

	printf("%d", result);

	

	return 0;

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

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

using namespace std;

int main(){

int n;

cin >> n;

cout << n*n*n << endl;

return 0;

}

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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

#include<cmath>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<pow(n,3);



    return 0;

}

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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

using namespace std;







int main()

{

  int N;

  cin>>N;

int x =N*N*N;

cout<<x;



		return 0;

}


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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

#include <cmath>

using namespace std;



int main()

{

    int n;

    cin >> n;

    int x=pow(n,3);

    cout << x;

    return 0;

}


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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


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



	int main() {

		int a;

		

		scanf("%i", &a, 1<a<9);

		printf("%i\n", a*a*a);

		

		return 0;

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

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

using namespace std;

int main(){

int n;

cin >> n;

cout << n*n*n << endl;

return 0;

}

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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

#include<cmath>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<pow(n,3);



    return 0;

}

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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

using namespace std;







int main()

{

  int N;

  cin>>N;

int x =N*N*N;

cout<<x;



		return 0;

}


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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

#include <cmath>

using namespace std;



int main()

{

    int n;

    cin >> n;

    int x=pow(n,3);

    cout << x;

    return 0;

}


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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


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

int main (){

	int n;

	scanf ("%d\n", &n);

	int luas = n*n*n;

	printf ("%d\n", luas);

	return 0;

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

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

using namespace std;

int main(){

int n;

cin >> n;

cout << n*n*n << endl;

return 0;

}

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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

#include<cmath>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<pow(n,3);



    return 0;

}

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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

using namespace std;







int main()

{

  int N;

  cin>>N;

int x =N*N*N;

cout<<x;



		return 0;

}


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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

#include <cmath>

using namespace std;



int main()

{

    int n;

    cin >> n;

    int x=pow(n,3);

    cout << x;

    return 0;

}


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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


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

int main(){

	int limit;

	scanf("%d", &limit);

	printf("%d", limit*limit*limit);

	

	return 0;

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

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

using namespace std;

int main(){

int n;

cin >> n;

cout << n*n*n << endl;

return 0;

}

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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

#include<cmath>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<pow(n,3);



    return 0;

}

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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

using namespace std;







int main()

{

  int N;

  cin>>N;

int x =N*N*N;

cout<<x;



		return 0;

}


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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

#include <cmath>

using namespace std;



int main()

{

    int n;

    cin >> n;

    int x=pow(n,3);

    cout << x;

    return 0;

}


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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


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



int main()

{	int N;

		scanf("%d", &N);

	int P;

		P = N*N*N;

			printf("%d", P);

	

	return 0;

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

#include <math.h>

using namespace std;



int n;

int main () {

cin>>n;

cout<<pow(n,3)<<endl;

}

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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

using namespace std;

int main(){

int n;

cin >> n;

cout << n*n*n << endl;

return 0;

}

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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

#include<cmath>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<pow(n,3);



    return 0;

}

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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

using namespace std;







int main()

{

  int N;

  cin>>N;

int x =N*N*N;

cout<<x;



		return 0;

}


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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

#include <cmath>

using namespace std;



int main()

{

    int n;

    cin >> n;

    int x=pow(n,3);

    cout << x;

    return 0;

}


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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

#include<cmath>

using namespace std;



int main()

{

    int b;

    cin>>b ;

    if(b==1)

        cout<<b;

    else cout<<pow(b,3);

    return 0;

}


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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

using namespace std; 

int main(){

int N;

cin >> N; 

cout<<N*N*N;

return 0; }

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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

using namespace std;

int main(){

    int n;

    cin>>n;

    cout<<n*n*n;

    return 0;

}


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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

using namespace std;

int main()

{

	ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    cout<<n*n*n;

}

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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

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

//#include <stdlib.h>

//#include <string.h>



using namespace std;



int main()

{

    int n;

    cin>>n;

    cout<<n*n*n;



    return 0;

}


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

int main(){

	int N;

	int result;

	scanf("%d", &N);

	result = N*N*N;

	printf("%d\n",result);

	return 0;

}