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.340473479740795x):
#include<stdio.h>



int main(){

	int n;

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

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

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

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

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

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int k;

    cin>>k;

    int b = pow(k,3);

    cout<<b;

    return 0;

}


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



int main(){

	int n;

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

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

#include <algorithm>

#include <cmath>

using namespace std;



int main() {



    int n; cin >> n;

    cout << pow(n, 3);

}

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



int main(){

	int n;

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

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

#include<math.h>



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;

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

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



#include<cmath>

using namespace std;



int main(){

int alaa;

cin>>alaa;

cout<<pow(alaa,3);









return 0;



}








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



int main(){

	int n;

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

}
// Slower C++ solution:


#include <iostream>

#include <cmath>



using namespace std;



int main()

{

    int A;

    cin>>A;

    cout<<pow(A,3);



    return 0;

}


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



int main(){

	int n;

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

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

#include<cmath>

using namespace std;

int main()

{

    double n,result;

    cin>>n;



    result=pow(n,3);



    printf("%.0lf",result);

}


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



int main(){

	int n;

	scanf("%d", &n);

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

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

using namespace std;



int main(){

    long long int a,b=1,c;

    cin>>a;

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



}


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

int main()

{

	int n;

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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



using namespace std;

int n, ans;

int main()

{

	cin >> n;

	ans = n * n * n;

	cout << ans << "\n";

	return 0;

}

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

int main()

{

	int n;

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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



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

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

#include<cstdio>

#include<cmath>

using namespace std;

int main()

{

	int a,b;

	cin>>a;

	b=pow(a,3);

	cout<<b;

	return 0;

}

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

int main()

{

	int n;

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

#include<cstdio>

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

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

using namespace std;

int main()

{

	int  ans;

	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;

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

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

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

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

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

	int 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 k;

    cin>>k;

    int b = pow(k,3);

    cout<<b;

    return 0;

}


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

int main()

{

	int n;

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

#include <algorithm>

#include <cmath>

using namespace std;



int main() {



    int n; cin >> n;

    cout << pow(n, 3);

}

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

int main()

{

	int n;

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

#include<math.h>



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;

	int 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 alaa;

cin>>alaa;

cout<<pow(alaa,3);









return 0;



}








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

int main()

{

	int n;

	int 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 A;

    cin>>A;

    cout<<pow(A,3);



    return 0;

}


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

int main()

{

	int n;

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

#include<cmath>

using namespace std;

int main()

{

    double n,result;

    cin>>n;



    result=pow(n,3);



    printf("%.0lf",result);

}


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

int main()

{

	int n;

	int hasil;

	

	scanf("%d",&n);

	

	hasil = n*n*n;

	printf("%d",hasil);	

	

	return 0;

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

using namespace std;



int main(){

    long long int a,b=1,c;

    cin>>a;

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



}


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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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



using namespace std;

int n, ans;

int main()

{

	cin >> n;

	ans = n * n * n;

	cout << ans << "\n";

	return 0;

}

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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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



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 n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

#include<cstdio>

#include<cmath>

using namespace std;

int main()

{

	int a,b;

	cin>>a;

	b=pow(a,3);

	cout<<b;

	return 0;

}

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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

#include<cstdio>

#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, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

using namespace std;

int main()

{

	int  ans;

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

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

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

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	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 n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

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 n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int k;

    cin>>k;

    int b = pow(k,3);

    cout<<b;

    return 0;

}


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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

#include <algorithm>

#include <cmath>

using namespace std;



int main() {



    int n; cin >> n;

    cout << pow(n, 3);

}

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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

#include<math.h>



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

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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



#include<cmath>

using namespace std;



int main(){

int alaa;

cin>>alaa;

cout<<pow(alaa,3);









return 0;



}








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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

}
// Slower C++ solution:


#include <iostream>

#include <cmath>



using namespace std;



int main()

{

    int A;

    cin>>A;

    cout<<pow(A,3);



    return 0;

}


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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

#include<cmath>

using namespace std;

int main()

{

    double n,result;

    cin>>n;



    result=pow(n,3);



    printf("%.0lf",result);

}


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



int main(){

	int n, l;

	scanf("%d",&n);

	l = n * n * n;

	printf("%d", l);

	return 0;

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

using namespace std;



int main(){

    long long int a,b=1,c;

    cin>>a;

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



}


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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

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



using namespace std;

int n, ans;

int main()

{

	cin >> n;

	ans = n * n * n;

	cout << ans << "\n";

	return 0;

}

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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

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



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

    scanf ("%d", &t);

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



    return 0;

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

#include<cstdio>

#include<cmath>

using namespace std;

int main()

{

	int a,b;

	cin>>a;

	b=pow(a,3);

	cout<<b;

	return 0;

}

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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

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

#include<cstdio>

#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 t;

    scanf ("%d", &t);

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



    return 0;

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

using namespace std;

int main()

{

	int  ans;

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

    scanf ("%d", &t);

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



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

    scanf ("%d", &t);

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



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

    scanf ("%d", &t);

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



    return 0;

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

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

    scanf ("%d", &t);

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



    return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int k;

    cin>>k;

    int b = pow(k,3);

    cout<<b;

    return 0;

}


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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

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

#include <algorithm>

#include <cmath>

using namespace std;



int main() {



    int n; cin >> n;

    cout << pow(n, 3);

}

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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

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

#include<math.h>



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

    scanf ("%d", &t);

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



    return 0;

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



#include<cmath>

using namespace std;



int main(){

int alaa;

cin>>alaa;

cout<<pow(alaa,3);









return 0;



}








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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

}
// Slower C++ solution:


#include <iostream>

#include <cmath>



using namespace std;



int main()

{

    int A;

    cin>>A;

    cout<<pow(A,3);



    return 0;

}


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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

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

#include<cmath>

using namespace std;

int main()

{

    double n,result;

    cin>>n;



    result=pow(n,3);



    printf("%.0lf",result);

}


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



int main () {



    int t;

    scanf ("%d", &t);

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



    return 0;

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

using namespace std;



int main(){

    long long int a,b=1,c;

    cin>>a;

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



}


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



int main() {

	

  int pass;

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

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



using namespace std;

int n, ans;

int main()

{

	cin >> n;

	ans = n * n * n;

	cout << ans << "\n";

	return 0;

}

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



int main() {

	

  int pass;

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

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



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

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

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

#include<cstdio>

#include<cmath>

using namespace std;

int main()

{

	int a,b;

	cin>>a;

	b=pow(a,3);

	cout<<b;

	return 0;

}

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



int main() {

	

  int pass;

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

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

#include<cstdio>

#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 pass;

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

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

using namespace std;

int main()

{

	int  ans;

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

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  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.345943631817677x):
#include <stdio.h>



int main() {

	

  int pass;

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

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

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

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

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

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

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

#include <cmath>



using namespace std;



int main()

{

    int k;

    cin>>k;

    int b = pow(k,3);

    cout<<b;

    return 0;

}


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



int main() {

	

  int pass;

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  return 0;

}