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

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



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;

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

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





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;



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

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



int main (){

int X;	

int jawaban;

	

scanf("%d", &X);	

jawaban = X*X*X;	

printf("%d",jawaban);	



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

	

scanf("%d", &X);	

jawaban = X*X*X;	

printf("%d",jawaban);	



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;	

int jawaban;

	

scanf("%d", &X);	

jawaban = X*X*X;	

printf("%d",jawaban);	



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;	

int jawaban;

	

scanf("%d", &X);	

jawaban = X*X*X;	

printf("%d",jawaban);	



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;	

int jawaban;

	

scanf("%d", &X);	

jawaban = X*X*X;	

printf("%d",jawaban);	



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;	

int jawaban;

	

scanf("%d", &X);	

jawaban = X*X*X;	

printf("%d",jawaban);	



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;	

int jawaban;

	

scanf("%d", &X);	

jawaban = X*X*X;	

printf("%d",jawaban);	



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

 scanf("%d",&n);

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



	

	return 0;	

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



using namespace std;



int main()

{

    int n; cin >> n;

    cout << n*n*n;;

    return 0;

}


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

int main(){	

 int n;

 scanf("%d",&n);

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



	

	return 0;	

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

using namespace std;

int main(){

    int N;

    cin>>N;

    int x;



    x=N*N*N;

    cout<<x;



   return 0;

}

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

int main(){	

 int n;

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

}


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

cin>>x;



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



    return 0;

}


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

using namespace std;

int main(void)

{

  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>



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.261629734747349x):
#include<cstdio>

int main(){

  int n;

  scanf("%d",&n);

  n=n*n*n;

  printf("%d",n);

  return 0;

}
// Slower C++ solution:
/*ANKON GHOSH

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

#define sf(a) scanf("%lld",&a)

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

#define pf(a) printf("%lld\n",a)

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

#define pff(a,b) printf("%lld %lld\n",a,b)

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

#define FOR(i,n) for(ll i=0;i<n;i++)

#define FOR1(i,n) for(ll i=1;i<=n;i++)

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    cin>>n;

    cout<<powl(n,3LL);

    return 0;

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


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



int main(){

    int a;

    scanf("%d", &a);

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

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

using namespace std;

#define ll long long int

#define co cout

#define ci cin

#define sf1(n) scanf("%lld",&n);

#define sf2(n,m) scanf("%lld %lld",&n,&m);

#define sf3(n,m,p) scanf("%lld %lld %lld",&n,&m,&p);

#define en cout<<endl;

#define pb push_back

#define coy cout<< "YES"<<endl;

#define con cout<< "NO"<<endl;

#define For(a,b) for(ll a=0;a<b;a++)

#define br break;

#define i64 long long

i64 M=10000000;

ll b[805],ans[805];

map< ll,pair<ll,ll> >mp;

//vector<ll>a;

int main()

{

    ll t,n,g,k,m,mx=0,mn=1e9,c,res,c1,x,y,c2;

    sf1(t)

    co<<t*t*t;

}




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



int main(){

    int a;

    scanf("%d", &a);

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

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

using namespace std;

int main(){

int n;



cin>>n;



long long int a = pow(n,3);

cout<<a<<endl;

return 0;

}


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



int main(){

    int a;

    scanf("%d", &a);

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

}
// Slower C++ solution:
/*ANKON GHOSH

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

#define sf(a) scanf("%lld",&a)

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

#define pf(a) printf("%lld\n",a)

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

#define pff(a,b) printf("%lld %lld\n",a,b)

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

#define FOR(i,n) for(ll i=0;i<n;i++)

#define FOR1(i,n) for(ll i=1;i<=n;i++)

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    cin>>n;

    cout<<powl(n,3LL);

    return 0;

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


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

#define ll long long int

#define co cout

#define ci cin

#define sf1(n) scanf("%lld",&n);

#define sf2(n,m) scanf("%lld %lld",&n,&m);

#define sf3(n,m,p) scanf("%lld %lld %lld",&n,&m,&p);

#define en cout<<endl;

#define pb push_back

#define coy cout<< "YES"<<endl;

#define con cout<< "NO"<<endl;

#define For(a,b) for(ll a=0;a<b;a++)

#define br break;

#define i64 long long

i64 M=10000000;

ll b[805],ans[805];

map< ll,pair<ll,ll> >mp;

//vector<ll>a;

int main()

{

    ll t,n,g,k,m,mx=0,mn=1e9,c,res,c1,x,y,c2;

    sf1(t)

    co<<t*t*t;

}




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



long long int a = pow(n,3);

cout<<a<<endl;

return 0;

}


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



int main(){

	int N;

	scanf ("%d", &N);

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

	return 0;

}
// Slower C++ solution:
/*ANKON GHOSH

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

#define sf(a) scanf("%lld",&a)

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

#define pf(a) printf("%lld\n",a)

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

#define pff(a,b) printf("%lld %lld\n",a,b)

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

#define FOR(i,n) for(ll i=0;i<n;i++)

#define FOR1(i,n) for(ll i=1;i<=n;i++)

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    cin>>n;

    cout<<powl(n,3LL);

    return 0;

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


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

int main(){

    int limit;

    scanf("%d", &limit);

    int result = limit * limit * limit;

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

    return 0;

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

using namespace std;

#define ll long long int

#define co cout

#define ci cin

#define sf1(n) scanf("%lld",&n);

#define sf2(n,m) scanf("%lld %lld",&n,&m);

#define sf3(n,m,p) scanf("%lld %lld %lld",&n,&m,&p);

#define en cout<<endl;

#define pb push_back

#define coy cout<< "YES"<<endl;

#define con cout<< "NO"<<endl;

#define For(a,b) for(ll a=0;a<b;a++)

#define br break;

#define i64 long long

i64 M=10000000;

ll b[805],ans[805];

map< ll,pair<ll,ll> >mp;

//vector<ll>a;

int main()

{

    ll t,n,g,k,m,mx=0,mn=1e9,c,res,c1,x,y,c2;

    sf1(t)

    co<<t*t*t;

}




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

int main(){

    int limit;

    scanf("%d", &limit);

    int result = limit * limit * limit;

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

    return 0;

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

using namespace std;

int main(){

int n;



cin>>n;



long long int a = pow(n,3);

cout<<a<<endl;

return 0;

}


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

int main(){

    int limit;

    scanf("%d", &limit);

    int result = limit * limit * limit;

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

    return 0;

}
// Slower C++ solution:
/*ANKON GHOSH

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

#define sf(a) scanf("%lld",&a)

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

#define pf(a) printf("%lld\n",a)

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

#define pff(a,b) printf("%lld %lld\n",a,b)

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

#define FOR(i,n) for(ll i=0;i<n;i++)

#define FOR1(i,n) for(ll i=1;i<=n;i++)

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    cin>>n;

    cout<<powl(n,3LL);

    return 0;

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


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



int main() {

  int num;

  scanf("%d", &num);



  int sum = num * num * num;

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

  return 0;

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

using namespace std;

#define ll long long int

#define co cout

#define ci cin

#define sf1(n) scanf("%lld",&n);

#define sf2(n,m) scanf("%lld %lld",&n,&m);

#define sf3(n,m,p) scanf("%lld %lld %lld",&n,&m,&p);

#define en cout<<endl;

#define pb push_back

#define coy cout<< "YES"<<endl;

#define con cout<< "NO"<<endl;

#define For(a,b) for(ll a=0;a<b;a++)

#define br break;

#define i64 long long

i64 M=10000000;

ll b[805],ans[805];

map< ll,pair<ll,ll> >mp;

//vector<ll>a;

int main()

{

    ll t,n,g,k,m,mx=0,mn=1e9,c,res,c1,x,y,c2;

    sf1(t)

    co<<t*t*t;

}




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



int main() {

  int num;

  scanf("%d", &num);



  int sum = num * num * num;

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

  return 0;

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

using namespace std;

int main(){

int n;



cin>>n;



long long int a = pow(n,3);

cout<<a<<endl;

return 0;

}


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



int main() {

  int num;

  scanf("%d", &num);



  int sum = num * num * num;

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

  return 0;

}
// Slower C++ solution:
/*ANKON GHOSH

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

#define sf(a) scanf("%lld",&a)

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

#define pf(a) printf("%lld\n",a)

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

#define pff(a,b) printf("%lld %lld\n",a,b)

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

#define FOR(i,n) for(ll i=0;i<n;i++)

#define FOR1(i,n) for(ll i=1;i<=n;i++)

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL)

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    cin>>n;

    cout<<powl(n,3LL);

    return 0;

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


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

 

int main ()

{

    int n;

    scanf ("%d", &n);

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

    return 0;

}