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

  

  scanf("%d", &pass);

  int result = pass*pass*pass;

  printf("%d", result);



  

  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;

  

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

  

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

  int result = pass*pass*pass;

  printf("%d", result);



  

  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;

  

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

    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;

	scanf ("%d", &N);

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



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

}

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

	scanf ("%d", &N);

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



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

	scanf ("%d", &N);

	printf ("%d", 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 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>



int main() {

	int N;

	scanf ("%d", &N);

	printf ("%d", 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.270830058264555x):
#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 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;

	scanf ("%d", &N);

	printf ("%d", 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.3365798837719005x):
#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);

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.3365798837719005x):
#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 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;

	scanf ("%d", &N);

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



int main() {

	int N;

	scanf ("%d", &N);

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



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

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf("%d", &a);

	rumus = a*a*a;

	printf ("%d", rumus);

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

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

	scanf ("%d", &g);

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

	

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

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

    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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

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

{

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 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 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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	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 number, possible;

	scanf("%d", &number);

	possible = number*number*number;

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

	return 0;	

}