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

	scanf("%d", &number);

	possible = number*number*number;

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

	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.338897011143218x):
#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 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.229850300284852x):
#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>



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

 scanf("%d", &n);

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

		

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



int main(){

 int n;

 scanf("%d", &n);

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

		

	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.331119313001772x):
#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>

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

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

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

		

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

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

		

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

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

		

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

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

		

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

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

		

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

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

		

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

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

		

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

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

		

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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;

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

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

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

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

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

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

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

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

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

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

	int jawab;

	

	scanf("%d", &pass);

	jawab = pass * pass * pass;

	printf("%d", jawab);

	

	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.338897011143218x):
#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 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.229850300284852x):
#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 << 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>

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

int main() {

    int x;

    scanf("%d", &x);

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

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.331119313001772x):
#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  ans;

	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>

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

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()

{

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

    scanf("%d", &x);

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

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

    scanf("%d", &x);

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

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

    scanf("%d", &x);

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

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

#include <stdlib.h>

#pragma warning(disable:4996)



int main() {

	int n = 0;

	scanf("%d", &n);



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



	// system("pause");

	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;

	scanf("%d", &x);

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



int main() {

	

	int x;

	scanf("%d", &x);

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

	

	return 0;

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

using namespace std;

int main(){

    int N;

    cin>>N;

    int x;



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

	scanf("%d", &x);

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

	

	return 0;

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

#include <math.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;

	scanf("%d", &x);

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

	

	return 0;

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

#include <cmath>



using namespace std;



int main()

{



int  x;

cin>>x;



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



    return 0;

}


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



int main() {

	

	int x;

	scanf("%d", &x);

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

	

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

	scanf("%d", &x);

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

	

	return 0;

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

using namespace std;

int main(void)

{

  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;

	scanf("%d", &x);

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

int main (){

	int pass;

	

	scanf("%d" , &pass);

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

	

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

	

	scanf("%d" , &pass);

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

	

	return 0;

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

using namespace std;

int main(){

    int N;

    cin>>N;

    int x;



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

	

	scanf("%d" , &pass);

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

	

	return 0;

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

#include <math.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 pass;

	

	scanf("%d" , &pass);

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

	

	return 0;

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

#include <cmath>



using namespace std;



int main()

{



int  x;

cin>>x;



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



    return 0;

}


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

int main (){

	int pass;

	

	scanf("%d" , &pass);

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

	

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

	

	scanf("%d" , &pass);

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

	

	return 0;

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

using namespace std;

int main(void)

{

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

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

	

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



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;

    int x;



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

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

	return 0;

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

#include <math.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 N;

scanf("%d",&N);

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

	return 0;

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

#include <cmath>



using namespace std;



int main()

{



int  x;

cin>>x;



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



    return 0;

}


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



int main(){

int N;

scanf("%d",&N);

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

	return 0;

}