stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



typedef long long ll;



ll power(ll a, ll b){

    ll ans = 1;

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

        ans *= a;

    }

    return ans;

}



int main() {

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    ll n, k;

    cin >> n >> k;

    if (k % 2 == 1)

        cout << power(n / k, 3) << endl;

    else

        cout << power(n / k, 3) + power((n + k / 2) / k, 3) << endl;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

#define ll long long

int main()

{

	//freopen("in.txt","r",stdin);

	ll n,k;

	scanf("%lld%lld",&n,&k);

	if(k&1){//ji

		if(k>n)printf("0\n");

		else{

			ll cnt1=(n-k)/k;

			cnt1++;

			printf("%lld",cnt1*cnt1*cnt1);

		}

	}else{

		if(k/2>n)printf("0\n");

		else{

			ll cnt1=0;

			if(k<=n){

		cnt1=(n-k)/k;

			cnt1++;

			}

		ll cnt2=(n-(k/2))/k;

		cnt2++;

		printf("%lld",cnt1*cnt1*cnt1+cnt2*cnt2*cnt2);

		}

	}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <vector>

 

using namespace std;

typedef long long ll;

 

// ll naive(ll N, ll K) {

//   int cnt = 0;

//   for (int a = 1; a <= N; a++) {

//     for (int b = 1; b <= N; b++) {

//       for (int c = 1; c <= N; c++) {

//         if ((a + b) % K == 0 && (b + c) % K == 0 && (a + c) % K == 0) {

//           cnt++;

//         }

//       }

//     }

//   }

//   return cnt;

// }



ll solve(ll N, ll K) {

  ll ans = 0;

  vector<ll> cnt(200001);

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

    cnt[i % K]++;

  }

  for(ll b = 1; b <= N; b++) {

    ll m = (K - b) % K;

    if (m < 0) {

      m += K * (-m / K) + K;

      m %= K;

    }

    if ((2 * m) % K == 0) {

      ans += cnt[m] * cnt[m];

    }

  }

  return ans;

}



int main() {

  ll N, K;

  cin >> N >> K;

  cout << solve(N, K) << endl;

  return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>



using namespace std;

#define all(x) (x).begin(), (x).end()

#define rep(i, n) for (int i = 0; i < (n); i++)

#define endl "\n"

typedef long long ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;



template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){os << "["; for (const auto &v : vec) {os << v << ","; } os << "]"; return os; }

template <typename T, typename U> ostream &operator<<(ostream &os, const pair<T, U> &p) {os << "(" << p.first << ", " << p.second << ")"; return os;}



void solve() {

    int N, K;

    cin >> N >> K;

    vector<ll> cnt(K);

    for(int i = 1; i <= N; i++) cnt[i % K]++;



    ll ans = 0;

    for(int b = 0; b < K; b++) {

        int a = (K - b) % K;

        int c = (K - b) % K;

        if ((a + c) % K != 0) continue;

        ans += cnt[a] * cnt[b] * cnt[c];

    }

    cout << ans << endl;

}



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);

    cout.setf(ios::fixed);

    cout.precision(16);

    solve();

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>



using namespace std;



int main()

{

    long long n, k, count = 0;

    long long res;

    cin >> n >> k;



    long long zero = 0;

    for (int i = 1; i <= n; i++)

    {

        if (i % k == 0)

            zero++;

    }

    res = zero * zero * zero;



    if (k % 2 == 0)

    {

        for (int i = 1; i <= n; i++)

        {

            if (i % k == k / 2)

                count++;

        }

        res += (count * count * count);

    }

    cout << res << endl;

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

#include <cmath>

using namespace std;

int n, k;

long long ans;

int main() {

	scanf("%d%d", &n, &k);

	if(k & 1) ans = (long long) pow(n / k, 3);

	else ans = (long long) pow(n / k, 3) + (long long) pow(n / k + (n % k >= k / 2), 3);

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

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
// In the name of God



#include <bits/stdc++.h>



using namespace std;



int main() {

	ios_base::sync_with_stdio(0), cin.tie(0);

	long long n, k;

	cin >> n >> k;

	long long ans = n / k;

	ans = ans * ans * ans;

	if(k % 2 == 0) {

		long long cnt = n / k;

		if(n % k >= k / 2) cnt++;

		ans += cnt*cnt*cnt;

	}

	cout << ans;

	return 0;

}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

#include <cmath>

using namespace std;

int n, k;

long long ans;

int main() {

	scanf("%d%d", &n, &k);

	if(k & 1) ans = (long long) pow(n / k, 3);

	else ans = (long long) pow(n / k, 3) + (long long) pow(n / k + (n % k >= k / 2), 3);

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

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef vector<int> vi;

typedef vector<ll> vll;

#define pu push

#define pb push_back

#define mp make_pair

#define eps 1e-7

#define INF 1000000000

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

#define sq(x) ((x)*(x))

#define fi first

#define sec second

#define SORT(x) sort((x).begin(),(x).end())

#define all(x) (x).begin(),(x).end()

#define rep(i,n) for(int (i)=0;(i)<(int)(n);(i)++)

#define repn(i,a,n) for(int (i)=(a);(i)<(int)(n);(i)++)

#define EQ(a,b) (abs((a)-(b))<eps)

int solve(){

	int T,D,L;

	cin >> T >> D >> L;

	if(T+D+L==0)return 1;

	vector<int> x(T);

	vector<int> rui(200100);

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

		cin >> x[i];

		if(x[i]>=L){

			rui[i]++;

			rui[i+D]--;

		}

	}

	for(int i=1;i<200100;i++)rui[i]+=rui[i-1];

	//for(int i=0;i<=T;i++)cout << i << ':' << rui[i] << endl;

	int ans = 0;

	for(int i=0;i<T-1;i++)if(rui[i])ans++;

	cout << ans << endl;

	return 0;

}

int main(){

	while(!solve()){}

	return 0;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

using namespace std;



typedef long long ll;



ll t,d,l;

ll x[100005];

ll i;

ll ans;



bool solve(){

	cin >> t >> d >> l;

	if(t == 0){

		return false;

	}

	for(i=0;i<t;i++){

		cin >> x[i];

	}

	ll value = 0;

	ans = 0;

	for(i=0;i<t-1;i++){

		if(x[i] >= l)value = d;

		if(value >= 1){

			ans++;

			value--;

		}

	}

	cout << ans << endl;

	return true;

}



int main(){

	while(solve()){}

	return 0;

}




// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>

using namespace std;

struct Node{

	int number, a;

} node[100005];



int cmp(Node a, Node b)

{

	return a.a < b.a;

}

int main()

{

	int n;

	cin >> n;

	for (int i = 1; i <= n; i++)

	{

		cin >> node[i].a;

		node[i].number = i; 

	}

	sort(node + 1, node + n + 1, cmp);

	for (int i = 1; i <= n; i++)

	{

		if (i != n)

		{

			cout << node[i].number << " ";

		}

		else

		{

			cout << node[i].number << endl;

		}

	}

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

const int maxn = 1e5 + 5;

struct Node {

    int id, num;

}node[maxn];

bool cmp(Node &a, Node &b) {

    return a.num < b.num;

}

//hh

int main() {

    int n;

    scanf("%d", &n);

    for(int i = 0; i < n; i++)

        scanf("%d", &node[i].num), node[i].id = i + 1;

    sort(node, node + n, cmp);

    for (int i = 0; i < n ; i++)

        printf("%d ", node[i].id);

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>

using namespace std;

int n,a[123456],b[123455];

bool PP(int i,int j){

    return a[i]<a[j];

}

int main(){

    cin>>n;

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

        cin>>a[i];

        b[i]=i;

    }

    sort(b+1,b+1+n,PP);

    for (int i=1;i<=n;i++)

    cout<<b[i]<<" ";

    return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

const int maxn = 1e5 + 5;

struct Node {

    int id, num;

}node[maxn];

bool cmp(Node &a, Node &b) {

    return a.num < b.num;

}

//hh

int main() {

    int n;

    scanf("%d", &n);

    for(int i = 0; i < n; i++)

        scanf("%d", &node[i].num), node[i].id = i + 1;

    sort(node, node + n, cmp);

    for (int i = 0; i < n ; i++)

        printf("%d ", node[i].id);

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>

#include <stdio.h>

#include <vector>

#include <iomanip>

#include <stdlib.h>



using namespace std;



#define LL long long

#define FOR(i,l,r) for(int i = l; i <= r; ++i)

#define REP(i,l,r) for(int i = l; i < r; ++i)

#define pi pair<int,int>

#define mp make_pair



const int maxN = 1e5 + 11;

const LL oo = 1e17 + 11;



int N,K;

int A[maxN],C[maxN];

bool cmp(int i,int j){

    return A[i] < A[j];

}



int main(){

    ios_base::sync_with_stdio(false);

    cin.tie();

    cout.tie();

    //



    cin >> N;

    FOR(i,1,N){

        cin >> A[i];

        C[i] = i;

    }

    sort(C + 1,C + 1 + N,cmp);

    //

    FOR(i,1,N) cout << C[i] << " ";



    return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

const int maxn = 1e5 + 5;

struct Node {

    int id, num;

}node[maxn];

bool cmp(Node &a, Node &b) {

    return a.num < b.num;

}

//hh

int main() {

    int n;

    scanf("%d", &n);

    for(int i = 0; i < n; i++)

        scanf("%d", &node[i].num), node[i].id = i + 1;

    sort(node, node + n, cmp);

    for (int i = 0; i < n ; i++)

        printf("%d ", node[i].id);

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

const int maxn=100000+50;



struct node{

	int id,rank;

	//node(int x,int y):id(x),rank(y){}

	bool operator <(const node& rhs) const {

		return rank<rhs.rank;

	}

}a[maxn];





int n,x,y;



int main(){

	scanf("%d",&n);

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

		scanf("%d",&x);

		a[i-1].id=i;a[i-1].rank=x;

	}

	sort(a,a+n);

	for(int i=0;i<n;i++)printf("%d ",a[i].id);

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

const int maxn = 1e5 + 5;

struct Node {

    int id, num;

}node[maxn];

bool cmp(Node &a, Node &b) {

    return a.num < b.num;

}

//hh

int main() {

    int n;

    scanf("%d", &n);

    for(int i = 0; i < n; i++)

        scanf("%d", &node[i].num), node[i].id = i + 1;

    sort(node, node + n, cmp);

    for (int i = 0; i < n ; i++)

        printf("%d ", node[i].id);

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <cstdio>

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cmath>

#include <vector>

#include <string>

using namespace std;

typedef long long ll;

const int maxn=2e5+10;

ll n,m,k,d,q;



pair<int,int> b[maxn];

int a[maxn];



int main()

{

    int n,k;

    cin>>n;

    int ans=0;

    for(int i=0;i<n;i++)

    {

        scanf("%d",&a[i]);

        b[i]=make_pair(a[i],i+1);

    }

    sort(b,b+n);

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

         printf(i!=n-1?"%d ":"%d",b[i].second);

    }

    return 0;

}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



int main() {

    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);



    int n;

    cin >> n;



    vector<array<int , 2> > v(n);

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

        int x;

        cin >> x;

        v[i - 1] = {x , i};

    }



    sort(v.begin() , v.end());



    for (auto &c : v)

        cout << c[1] << ' ';

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;

const int N=3e5+5;

int a[N];

int main()

{

    ios_base::sync_with_stdio(0);

    cin.tie(0);cout.tie(0);

    int n;

    cin>>n;

    vector<pair<int,int> >v;

    for(int i=1;i<=n;i++)

    {

        int x;

        cin>>x;

        v.push_back({x,i});

    }

    sort(v.begin(),v.end());

    for(int i=0;i<v.size();i++)

    {

        if(i) cout<<" ";

        cout<<v[i].second;

    }

    cout<<endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

 

using namespace std;

 

typedef int in;

#define int long long

 

in main() {

    int n;

    cin >> n;

    vector<pair<int,int> > v;

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

        int a;

        cin >> a;

        v.push_back({a,i + 1});

    }

    sort(v.begin(),v.end());

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

        if(i){

            cout << " ";

        }

        cout << v[i].second;

    }

    cout << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#include<cstdio>

#define ll long long int

#define pb push_back

using namespace std;

int main()

{

    ll a,b,n,i,j,k;

    vector<ll>v[60];

    map<ll,ll>m;

    set<ll>s;

    cin>>n;

    for(i=1;i<=n;i++)

    {

        cin>>k;

        m[k]=i;

        s.insert(k);

    }

    for(auto x:s)

    {

        cout<<m[x]<<" ";

    }

    cout<<endl;



    return 0;

}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define  ft  ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

#define  ll  long long

#define  pi  pair<int,int>

#define  pb  push_back

#define  F   first

#define  S   second

const int N=2e5+2;

pi a[N];

int main()

{

    ft

    int t,i,j,n,m,l=0,r,z=0;

    cin>>n;

    for(i=1;i<=n;i++)

    {

        cin>>l;

        a[i]={l,i};

    }

    sort(a+1,a+n+1);

    for(i=1;i<=n;i++)

    {

        cout<<a[i].S<<" ";

    }

    return 0;

}




// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

#define ll long long int

#define sz  200010

using namespace std;





priority_queue<pair<ll,ll> >q;







int main()

{



   ll n,i,j,a,b,x,y;



   cin>>n;



   for(i=1;i<=n;i++)

   {

       cin>>a;

       q.push({-a,i});

   }

   ll c=0;





   while(!q.empty())

   {

       a=q.top().second;

       q.pop();

       c++;

       cout<<a;

       if(c!=n)cout<<" ";



   }

   cout<<endl;





  return 0;

}




// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n,i,j,x;

    cin>>n;

    vector<pair<int,int> >vi;

    for(i =1 ;i<=n;i++)

    {

        cin>>x;

        vi.push_back(make_pair(x,i));

    }

    sort(vi.begin(),vi.end());

    for(i = 0;i<n;i++)

    {

        cout<<vi[i].second<<" ";

    }

    cout<<endl;

}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <map>



using namespace std;



int main(int argc, char const *argv[])

{

    int n, stu;

    cin >> n;

    map<int, int> pos;

    for (int i = 1; i <= n; i++)

    {

        cin >> stu;

        pos[stu] = i;

    }

    for (auto m : pos)

    {

        cout << m.second << " ";

    }

    return 0;

}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;



int main(){

	int n;

	cin >> n;

	vector<pair<int, int> > v;

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

		int x;

		cin >> x;

		v.push_back(make_pair(x, i+1));

	}

	sort(v.begin(), v.end());

	for (int i=0; i<v.size()-1; i++){

		cout << v[i].second << " ";

	}

	cout << v[v.size()-1].second << "\n";

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define found(m,x) ((m).find(x)!=(m).end())

#define uset unordered_set

#define umap unordered_map

#define db(x) cerr << #x << " == " << x << ";\n";

#define a(x) x.begin(),x.end()

#define input(v,n) for(int i=0;i<n;i++)cin>>v[i]

typedef vector<int> vi;

typedef pair<int,int> pi;



const int nax = 1e5+7;

const int mod = 1e9+7; //1e9+2667

const int inf = numeric_limits<int> :: max();

// ===================== MANASH =================== //



int n,m;



void test() {



	cin >> n;

	vector<pair<int,int>> arr;

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

		int a;

		cin >> a;

		arr.push_back({a,i+1});

	}

	sort(a(arr));



	for( auto p : arr ) {

		cout << p.second << ' ';

	}

}





signed main() {



	ios_base :: sync_with_stdio(false);

	cin.tie(NULL);



	#ifdef LOCAL

	freopen("input.txt","r",stdin);

	cout<<"Time Elapsed: " << 1.0*clock() / CLOCKS_PER_SEC << " sec.\n";

	#endif



	int T = 1;

	//cin >> T;

	while(T--) {

		test();

		cout << "\n";

	}

	return 0;



}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<string>

#include<algorithm>

#include<math.h>

#include<stdio.h>

#define MAXN 100010

using namespace std;

int n;

struct stu

{

    int num;

    int idx;

    bool operator < (const stu & x) const{

        return num<x.num;

    }

}a[MAXN];

int main()

{

    cin>>n;

    int x;

    for(int i=1;i<=n;i++)

    {

        cin>>x;

        a[i].idx=i;

        a[i].num=x;

    }

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)   cout<<a[i].idx<<" ";

    cout<<endl;

    return 0;

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

const int maxn=1e5+10;

int N;

struct S{

	int index;

	int num;

	bool operator <(const S& x)const{

		return num<x.num;

	}

}A[maxn];



int main()

{

	cin>>N;

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

		cin>>A[i].num;

		A[i].index=i+1;

	}

	sort(A,A+N);

	for(int i=0;i<N;i++)

        cout<<A[i].index<<' ';

    cout<<endl;

	

	

	return 0;

}

// Optimized solution to the same problem (faster):
#include <algorithm>

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&a[i].first);

        a[i].second=i;

    }

        

    sort(a+1,a+n+1);

    for(int i=1;i<=n;i++)

    {

        printf("%d ",a[i].second);

    }









    return 0;

}


// Fastest known solution for this problem: