stablegradients/pie-gem5-pairs huggingface dataset:
// 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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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 a,b;

	

	scanf ("%d", &a);

	

	b = a*a*a;

	printf ("%d", b);

	

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, H;

	scanf("%d", &N);

	H=N*N*N;

	printf("%d", H);

	

	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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  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, hasil;

 

  scanf("%d", &n);

  

  hasil = n*n*n;

  

  printf("%d", hasil);

 

  return 0;

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

#include <math.h>

using namespace std;

int main()

{

    int x,ans;

    cin>>x;

    ans=pow(x,3);

    cout<<ans<<endl;

    return 0;

}


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

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

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

	

	return 0;

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

using namespace std;



int main()

{

	int N;

	cin >> N;

	cout << N*N*N;

}

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

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

	printf("%d",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.261629022032166x):
#include <stdio.h>

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

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

	

	return 0;

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

using namespace std;

int main()

{

    int n;

    cin>>n;

    int res=1;

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

        res*=n;

    }

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

    return 0;

}

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

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

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

	

	return 0;

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

using namespace std;

int n;

int main () {

	cin >> n;

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

}


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

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

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

	

	return 0;

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

using namespace std;

int main(){

	int n;cin>>n;cout<<pow(n,3)<<endl;

}

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

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

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

	

	return 0;

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

using namespace std;

int n;

int main () {

cin >> n;

cout << (n*n*n) << endl;

}


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

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

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

	

	return 0;

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

#include <cmath>



using namespace std;



int main(void) {



	int input;



	cin >> input;



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



	return 0;

}

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

#include <stdlib.h>

#pragma warning(disable:4996)



int main()

{

	int n;

	scanf("%d",&n);

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

	

	return 0;

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

#include <math.h>

using namespace std;

int main()

{

    int x,ans;

    cin>>x;

    ans=pow(x,3);

    cout<<ans<<endl;

    return 0;

}


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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

using namespace std;



int main()

{

	int N;

	cin >> N;

	cout << N*N*N;

}

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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

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

	scanf("%d",&x);

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

	

	

	return 0;

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

using namespace std;

int main()

{

    int n;

    cin>>n;

    int res=1;

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

        res*=n;

    }

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

    return 0;

}

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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

using namespace std;

int n;

int main () {

	cin >> n;

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

}


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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

using namespace std;

int main(){

	int n;cin>>n;cout<<pow(n,3)<<endl;

}

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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

using namespace std;

int n;

int main () {

cin >> n;

cout << (n*n*n) << endl;

}


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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

#include <cmath>



using namespace std;



int main(void) {



	int input;



	cin >> input;



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



	return 0;

}

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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

#include <cmath>

using namespace std;



int main()

{

    int N;

    cin>>N;

    if(N==1)

        cout<<N<<endl;

    else

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

    return 0;

}


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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

using namespace std;



int main() {

    int num;

    cin >> num;

    cout << num*num*num;

    return 0;

}


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



int main(){

	

	int x;

	scanf("%d",&x);

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

	

	

	return 0;

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

#include <math.h>

using namespace std;

int main()

{

    int x,ans;

    cin>>x;

    ans=pow(x,3);

    cout<<ans<<endl;

    return 0;

}


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

int main(){

	

int num;

int result;

scanf("%d", &num);

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;

}

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

int main(){

	

int num;

int result;

scanf("%d", &num);

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;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

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

using namespace std;

int main()

{

    int n;

    cin>>n;

    int res=1;

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

        res*=n;

    }

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

    return 0;

}

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

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

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

using namespace std;

int n;

int main () {

	cin >> n;

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

}


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

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

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

using namespace std;

int main(){

	int n;cin>>n;cout<<pow(n,3)<<endl;

}

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

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

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

using namespace std;

int n;

int main () {

cin >> n;

cout << (n*n*n) << endl;

}


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

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

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

#include <cmath>



using namespace std;



int main(void) {



	int input;



	cin >> input;



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



	return 0;

}

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

int main(){

	

int num;

int result;

scanf("%d", &num);

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;

    if(N==1)

        cout<<N<<endl;

    else

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

    return 0;

}


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

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

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

using namespace std;



int main() {

    int num;

    cin >> num;

    cout << num*num*num;

    return 0;

}


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

int main(){

	

int num;

int result;

scanf("%d", &num);

result = num * num * num;

printf("%d", result);

return 0;

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

#include <math.h>

using namespace std;

int main()

{

    int x,ans;

    cin>>x;

    ans=pow(x,3);

    cout<<ans<<endl;

    return 0;

}


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



int main (){



int x ;

int d ;

scanf ("%d" , &x );

d = x*x*x;

printf("%d" ,d );

	

 return 0;

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

using namespace std;



int main()

{

	int N;

	cin >> N;

	cout << N*N*N;

}

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



int main (){



int x ;

int d ;

scanf ("%d" , &x );

d = x*x*x;

printf("%d" ,d );

	

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

int d ;

scanf ("%d" , &x );

d = x*x*x;

printf("%d" ,d );

	

 return 0;

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

using namespace std;

int main()

{

    int n;

    cin>>n;

    int res=1;

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

        res*=n;

    }

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

    return 0;

}

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



int main (){



int x ;

int d ;

scanf ("%d" , &x );

d = x*x*x;

printf("%d" ,d );

	

 return 0;

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

using namespace std;

int n;

int main () {

	cin >> n;

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

}


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



int main (){



int x ;

int d ;

scanf ("%d" , &x );

d = x*x*x;

printf("%d" ,d );

	

 return 0;

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

using namespace std;

int main(){

	int n;cin>>n;cout<<pow(n,3)<<endl;

}

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



int main (){



int x ;

int d ;

scanf ("%d" , &x );

d = x*x*x;

printf("%d" ,d );

	

 return 0;

}