stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



map<pair<int,int>,ll> f[MAXN];



ll get_sum_naive(int s,int d,int k) {

	if (f[s].count({d,k})) return f[s][{d,k}];

	ll sum=0;

	rep(i,0,k+1) sum+=S[s+i*d];

	f[s][{d,k}]=sum;

	return sum;

}



ll check_naive(int A,int d) {

	if (A<=d) return 0;

	int k=(N-1-A)/d;

	if (A%d==0 && k>=A/d) return 0;

	return get_sum_naive(0,d,k) + get_sum_naive(A,d,k);

}



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;

			res=max(res,check_naive(A,k));

			

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

}


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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



ll get_sum_naive(int s,int d,int k) {

	ll sum=0;

	rep(i,0,k+1) sum+=S[s+i*d];

	return sum;

}



ll check_naive(int A,int d,int k) {

	if (A<=d || (A%d==0 && k>=A/d)) return 0;

	return get_sum_naive(0,d,k) + get_sum_naive(A,d,k);

}



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;

			res=max(res,check_naive(A,k,d));

			

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



map<pair<int,int>,ll> f[MAXN];



ll get_sum_naive(int s,int d,int k) {

	if (f[s].count({d,k})) return f[s][{d,k}];

	ll sum=0;

	rep(i,0,k+1) sum+=S[s+i*d];

	f[s][{d,k}]=sum;

	return sum;

}



ll check_naive(int A,int d) {

	if (A<=d) return 0;

	int k=(N-1-A)/d;

	if (A%d==0 && k>=A/d) return 0;

	return get_sum_naive(0,d,k) + get_sum_naive(A,d,k);

}



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;

			res=max(res,check_naive(A,k));

			

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

}


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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;		

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



map<pair<int,int>,ll> f[MAXN];



ll get_sum_naive(int s,int d,int k) {

	if (f[s].count({d,k})) return f[s][{d,k}];

	ll sum=0;

	rep(i,0,k+1) sum+=S[s+i*d];

	f[s][{d,k}]=sum;

	return sum;

}



ll check_naive(int A,int d) {

	if (A<=d) return 0;

	int k=(N-1-A)/d;

	if (A%d==0 && k>=A/d) return 0;

	return get_sum_naive(0,d,k) + get_sum_naive(A,d,k);

}



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;

			res=max(res,check_naive(A,k));

			

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

}


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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	int N;

	cin>>N;

	vector<int> S(N);

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	rep(d,1,N-1) {

		ll sum=0;

		set<int> was;

		for (int k=1; k*d<N-1; k++) {

			sum+=S[k*d]+S[N-1-k*d];

			if (was.count(k*d)) break;

			was.insert(k*d);

			if (was.count(N-1-k*d)) break;

			was.insert(N-1-k*d);

			

			int A=N-1-k*d;

			int B=A-d;

			if (B>0 && A>=B) res=max(res,sum);

		}

	}



	cout<<res<<"\n";

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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



map<pair<int,int>,ll> f[MAXN];



ll get_sum_naive(int s,int d,int k) {

	if (f[s].count({d,k})) return f[s][{d,k}];

	ll sum=0;

	rep(i,0,k+1) sum+=S[s+i*d];

	f[s][{d,k}]=sum;

	return sum;

}



ll check_naive(int A,int d) {

	if (A<=d) return 0;

	int k=(N-1-A)/d;

	if (A%d==0 && k>=A/d) return 0;

	return get_sum_naive(0,d,k) + get_sum_naive(A,d,k);

}



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;

			res=max(res,check_naive(A,k));

			

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

}


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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	int N;

	cin>>N;

	vector<int> S(N);

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	rep(d,1,N-1) {

		ll sum=0;

		for (int k=1; k*d<N-1; k++) {

			sum+=S[k*d]+S[N-1-k*d];

			int A=N-1-k*d;

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			res=max(res,sum);

		}

	}



	cout<<res<<"\n";

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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



map<pair<int,int>,ll> f[MAXN];



ll get_sum_naive(int s,int d,int k) {

	if (f[s].count({d,k})) return f[s][{d,k}];

	ll sum=0;

	rep(i,0,k+1) sum+=S[s+i*d];

	f[s][{d,k}]=sum;

	return sum;

}



ll check_naive(int A,int d) {

	if (A<=d) return 0;

	int k=(N-1-A)/d;

	if (A%d==0 && k>=A/d) return 0;

	return get_sum_naive(0,d,k) + get_sum_naive(A,d,k);

}



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;

			res=max(res,check_naive(A,k));

			

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

}


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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	int N;

	cin>>N;

	vector<int> S(N);

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	rep(d,1,N-1) {

		ll sum=0;

		for (int k=1; k*d<N-1; k++) {

			sum+=S[k*d]+S[N-1-k*d];

			int A=N-1-k*d;

			if (A>d && (A%d!=0 || k<A/d)) res=max(res,sum);

		}

	}



	cout<<res<<"\n";

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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int const MAXN=110000;

int N;

int S[MAXN];



map<pair<int,int>,ll> f[MAXN];



ll get_sum_naive(int s,int d,int k) {

	if (f[s].count({d,k})) return f[s][{d,k}];

	ll sum=0;

	rep(i,0,k+1) sum+=S[s+i*d];

	f[s][{d,k}]=sum;

	return sum;

}



ll check_naive(int A,int d) {

	if (A<=d) return 0;

	int k=(N-1-A)/d;

	if (A%d==0 && k>=A/d) return 0;

	return get_sum_naive(0,d,k) + get_sum_naive(A,d,k);

}



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	cin>>N;

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		vector<vector<ll>> sums(d);

		rep(i,0,N) {

			ll v=S[i];

			if (!sums[i%d].empty()) v+=sums[i%d].back();

			sums[i%d].push_back(v);

		}

		

		rep(A,1,N-1) if ((N-1-A)%d==0) {

			int k=(N-1-A)/d;

			res=max(res,check_naive(A,k));

			

			if (A<=d || (A%d==0 && k>=A/d)) continue;

			

			ll sum=sums[0][k];

			sum+=sums[A%d][A/d+k];

			if (A/d>0) sum-=sums[A%d][A/d-1];

			res=max(res,sum);

		}

	}

		

	cout<<res<<"\n";

}


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

#define sz(c)      int(c.size())

#define rep(i,a,b) for (int i=a; i<(b); ++i)

#define per(i,a,b) for (int i=(b)-1; i>=(a); --i)

using namespace std;

using ll = long long;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(0);

	cout<<fixed<<setprecision(10);



	int N;

	cin>>N;

	vector<int> S(N);

	rep(i,0,N) cin>>S[i];

	

	ll res=0;

	for (int d=1; d*d<=N; ++d) {

		ll sum=0;

		for (int k=1; k*d<N-1; k++) {

			sum+=S[k*d]+S[N-1-k*d];

			int A=N-1-k*d;

			if (A>d && (A%d!=0 || k<A/d)) res=max(res,sum);

		}

	}



	cout<<res<<"\n";

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

#include <iostream>

#include <algorithm>

using namespace std;

int N, x, A[50176];

int main() {

	// step #1. read input

	cin.tie(0);

	ios_base::sync_with_stdio(false);

	cin >> N;

	int H = (N >> 1);

	for (int i = 0; i < H; ++i) {

		cin >> A[i];

	}

	if (N % 2 == 1) {

		cin >> x;

	}

	for (int i = H - 1; i >= 0; --i) {

		cin >> x;

		A[i] += x;

	}

	// step #2. calculate the answer

	long long ans = 0;

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

		long long sum = 0;

		int pos = i;

		while (pos < H) {

			sum += A[pos];

			ans = max(ans, sum);

			pos += i;

		}

		if ((N - 1) % i != 0) {

			pos = (N - 1) - pos;

			while (pos >= i) {

				sum += A[pos];

				ans = max(ans, sum);

				pos -= i;

			}

		}

	}

	cout << ans << endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.377510188535802x):
#include <cstdio>

#include <algorithm>

int readint() {

	char ch = getchar();

	int res = 0; bool f = false;

	if (ch == '-') {

		f = true;

		ch = getchar();

	}

	while ('0' <= ch && ch <= '9') {

		res = res * 10 + ch - '0';

		ch = getchar();

	}

	if (f) res = -res;

	return res;

}

int A[50176];

int main() {

	// step #1. read input

	int N = readint();

	int H = (N >> 1);

	for (int i = 0; i < H; ++i) A[i] = readint();

	if (N & 1) readint();

	for (int i = H - 1; i >= 0; --i) A[i] += readint();

	// step #2. calculate the answer

	long long ans = 0;

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

		long long sum = 0;

		int pos = i;

		while (pos < H) {

			sum += A[pos];

			ans = std::max(ans, sum);

			pos += i;

		}

		if ((N - 1) % i != 0) {

			pos = (N - 1) - pos;

			while (pos >= i) {

				sum += A[pos];

				ans = std::max(ans, sum);

				pos -= i;

			}

		}

	}

	printf("%lld\n", ans);

	return 0;

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

#include <iostream>

#include <algorithm>

using namespace std;

int N, x, A[50176];

int main() {

	// step #1. read input

	cin.tie(0);

	ios_base::sync_with_stdio(false);

	cin >> N;

	int H = (N >> 1);

	for (int i = 0; i < H; ++i) {

		cin >> A[i];

	}

	if (N % 2 == 1) {

		cin >> x;

	}

	for (int i = H - 1; i >= 0; --i) {

		cin >> x;

		A[i] += x;

	}

	// step #2. calculate the answer

	long long ans = 0;

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

		long long sum = 0;

		int pos = i;

		while (pos < H) {

			sum += A[pos];

			ans = max(ans, sum);

			pos += i;

		}

		if ((N - 1) % i != 0) {

			pos = (N - 1) - pos;

			while (pos >= i) {

				sum += A[pos];

				ans = max(ans, sum);

				pos -= i;

			}

		}

	}

	cout << ans << endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.39481331022776x):
#include <cstdio>

#include <algorithm>

int readint() {

	char ch = getchar();

	int res = 0; bool f = false;

	if (ch == '-') {

		f = true;

		ch = getchar_unlocked();

	}

	while ('0' <= ch && ch <= '9') {

		res = res * 10 + ch - '0';

		ch = getchar_unlocked();

	}

	if (f) res = -res;

	return res;

}

int A[50176];

int main() {

	// step #1. read input

	int N = readint();

	int H = (N >> 1);

	for (int i = 0; i < H; ++i) A[i] = readint();

	if (N & 1) readint();

	for (int i = H - 1; i >= 0; --i) A[i] += readint();

	// step #2. calculate the answer

	long long ans = 0;

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

		long long sum = 0;

		int pos = i;

		while (pos < H) {

			sum += A[pos];

			ans = std::max(ans, sum);

			pos += i;

		}

		if ((N - 1) % i != 0) {

			pos = (N - 1) - pos;

			while (pos >= i) {

				sum += A[pos];

				ans = std::max(ans, sum);

				pos -= i;

			}

		}

	}

	printf("%lld\n", ans);

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



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

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

int main () {



int n;

scanf ("%d", &n);



int possible;

possible = n*n*n;

printf ("%d",  possible);

	

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



int possible;

possible = n*n*n;

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

	int tot=0;

	tot = n*n*n;

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

	

	

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

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

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

	int tot=0;

	tot = n*n*n;

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

	

	

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

	int tot=0;

	tot = n*n*n;

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

	

	

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

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

{

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

	int tot=0;

	tot = n*n*n;

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

	

	

	return 0;

}