stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
/******************************************

* AUTHOR : RAJAGOPALAN *

* NICK : ARNO *

* INSTITUTION : VIT *

******************************************/

#include <bits/stdc++.h>

#include <ext/pb_ds/detail/standard_policies.hpp>

#define ll long long

#define ull unsigned long long

#define pb push_back

#define mp make_pair

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

#define alli(a, n, k) (a+k),(a+n+k)

#define FP(i, a, b, k) for(__typeof(a) i = a;i < b;i += k)

#define FS(i, a, b, k) for(__typeof(a) i = a;i > b;i -= k)

#define IT(it, a) for(__typeof(a.begin()) it = a.begin();it != a.end(); ++it)

#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>

#define eps 1e-6

#define pi 3.141592653589793

using namespace std;

using namespace __gnu_pbds;



template<class T> inline T gcd(T x, T y) { if (!y) return x; return gcd(y, x%y);}

typedef vector<int> VII;

typedef vector<ll> VLL;

typedef pair<int, int> PII;

typedef vector< pair<int, int> > VPII;

typedef vector< pair<int, PII > > VPPI;

const int MOD = 1e9 + 7;

const int INF = 1e9;



inline ll modulo(ll a, ll m)

{

    return (a % m + m) % m;

}



inline ll modInverse(ll a, ll m)

{

    assert(__gcd(a, m) == 1);

    ll m0 = m;

    ll y = 0, x = 1;



    if (m == 1)

        return 0;



    while (a > 1)

    {

        ll q = a / m;

        ll t = m;



        m = a % m, a = t;

        t = y;



        y = x - q * y;

        x = t;

    }



    if (x < 0)

        x += m0;



    return x;

}



inline ll modPow(ll x, ll y, ll m)

{ //x^y % m

    if (y == 0)

        return 1LL;

    else if (y == 1)

        return x;

    else

    {

        ll ans = modPow(x, y / 2, m) % m;

        if (y & 1)

        {

            return (((ans * ans) % m) * x) % m;

        }

        else

        {

            return (ans * ans) % m;

        }

    }

}



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

{

    ios::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    VPII arr;

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

    {

        int x;

        cin>>x;

        arr.pb({x,i});

    }

    sort(all(arr),less<PII>());

    for(auto xx:arr)

    cout<<xx.second<<' ';

    return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



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;

	int arr[n+2];

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

	{

		cin>>arr[i];

	}

	priority_queue <pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>> > pq;

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

	{

		pq.push({arr[i],i});

	}

	while(pq.size()>0)

	{

		cout<<pq.top().second<<" ";

		pq.pop();

	}

	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

int n;

struct ti{

	int id,a;

}x[100010];

bool cmp(ti x,ti y){

	return x.a<y.a ;

}

int main(){

	cin>>n;

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

		cin>>x[i].a;

		x[i].id=i;	

	}

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

	for(int i=1;i<=n;i++)cout<<x[i].id<<' ';cout<<endl;

	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<string>

#include<cstring>

#include<algorithm>

using namespace std;



struct point

{

	int num;

	int val;

	bool operator<(const point p)

	{

		return val<p.val;

	}

}a[100010];

int main()

{    

   int n;cin>>n;

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

    {

    	cin>>a[i].val;a[i].num=i;

	}

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

	

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

    {

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

	}cout<<endl;

   

   return 0;

} 

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <vector>

#include <algorithm>

using namespace std;



struct peo {

	int no, c;

	peo() { no = 0; c = 0; }

	peo(int _n, int _c) :no(_n), c(_c) {  }

	bool operator<(const peo& p) {

		return c < p.c;

	}

};



int main() {

	int n;

	cin >> n;

	vector<peo> v;

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

		int a;

		cin >> a;

		peo p(i, a);

		v.push_back(p);

	}

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

	cout << v[0].no;

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

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

	cout << endl;



	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <cmath>

#include <iostream>

#include <algorithm>

#include <string.h>

#include <string>

#include <map>

using namespace std;

const int maxN=1e7;

struct student{

    int n;

    int all;

}S[maxN];

bool cmp(student s1,student s2){

    return s1.all<s2.all;

}

int main(){

    int m;

    cin>>m;

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

        cin>>S[i].all;

        S[i].n=i;

    }

    sort(S+1,S+m+1,cmp);

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

        if(i==m){

            cout<<S[i].n<<endl;

        }else

        {

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

        }

        

        

    }

    

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <string.h>

#include <algorithm>

using namespace std;

const int maxn=1e5+5;

struct student{

    int seq,num;

    bool operator<(student s)const{return num<s.num;}

}stu[maxn];



int main(){

    int n;

    cin>>n;

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

        stu[i].seq=i;

        cin>>stu[i].num;

    }

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

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

        cout<<stu[i].seq<<" ";

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<algorithm>

#include<vector>

using namespace std;

int N,temp;

struct node{

	int number,count;

	bool operator<(const node& n) const{

		return count<n.count;

	}

};

vector<node> v;

int main(){

	cin>>N;

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

		cin>>temp;

		v.push_back({i,temp});		

	}

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

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

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

	}

	cout<<endl;

} 

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<algorithm>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

using namespace std;

int A[100050],B[100050];

int n;

int main(int argc, char** argv) 

{

	cin>>n;

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

	{

		cin>>A[i];

		B[A[i]]=i;

	}

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

	for(int i=1;i<=n;i++)cout<<B[A[i]]<<" ";

	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<iostream>

#include<cstring>

#include<string>

#include<algorithm>



using namespace std;



struct node {

    int id, val;

}stu[100010];



inline int cmp(const node& a, const node& b) {return a.val < b.val;}

int main() {

    int n; 

    cin >> n;

    for (int i = 1; i <= n; ++i) scanf("%d", &stu[i].val), stu[i].id = i;

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

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

    printf("%d\n", stu[n].id);

    // system("pause");

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<stdio.h>

#include<algorithm>

using namespace std;

int main()

{

	int n;

	cin>>n;

	int *a=new int[n+1];

	int *cnt=new int[n+1];

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

	{

		cin>>a[i];

		cnt[a[i]]=i;

	}

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

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

	{

		if(i<n)

		{

			cout<<cnt[a[i]]<<" ";

		}

		else

		{

			cout<<cnt[a[i]]<<endl;

		}

			

	} 

	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<cstring>

#include<cstdio>

#include<string>

#include<algorithm>

#include<cmath>

#include<cstdlib>

#include<iomanip>

#include <map>

#define ll long long

#define MAXN 105 

using namespace std;



struct node{

	int num;

	int rest;

}a[100005];



bool cmp(struct node x,struct node y)

{

	return x.rest < y.rest;

}



int main()

{

	int n;

	cin >> n;

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

	{

		cin >> a[i].rest;

		a[i].num = i+1;

	}

	sort(a,a+n,cmp);

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

	{

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

	}

	cout << endl;

    return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <cstdio>

#include <cstring>

#include <string>

#include <algorithm>

using namespace std;



pair<int,int> stu[100005];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

        int temp;

        scanf("%d",&temp);

        stu[i] = make_pair(temp,i+1);

    }

    sort(stu,stu+n);

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

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

    return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<algorithm>

using namespace std;

struct stu{

	int rank;

	int ai;

}a[100010];

bool cmp(stu x,stu y){

	return x.ai<y.ai;

}

int main(){

	int n;

	cin>>n;

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

	{

		cin>>a[i].ai;

		a[i].rank=i;

	}

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

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

		cout<<a[i].rank;

		if(i<n)

		cout<<" ";

	}

	return 0;

} 

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<stdio.h>

#include<map>

using namespace std;



map<int, int> a;



int main()

{

	int n, num;

	cin>>n;

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

	{

		cin>>num;

		a[num] = i;

	}

	map<int, int>::iterator it;

	for(it=a.begin();it!=a.end();it++)

		cout<<it->second<<" ";

	cout<<endl;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <cstdio>

#include <cstdlib>

#include <cmath>

#include <cstring>

#include <string>

#include <climits>

#include <algorithm>

#include <queue>

#include <vector>

#include <map>

#include <utility>

using namespace std;

int n;

pair<int, int> a[100005];//人数，编号

int main(){

    cin>>n;

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

        int x;

        cin>>x;

        a[i]=pair<int, int>(x,i);

    }

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

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

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

    }

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <cstring>

#include <string>

#include <cmath>

#include <algorithm>

#include <vector>

#include <cstdio>

using namespace std;

int n;

struct stu

{

	int k;

	int num;

	bool operator<(const stu &a)const

    {

        return num < a.num;

    }



}a[100010];

int main()

{	

    cin>>n;

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

    {

    	a[i].k = i;

    	cin>>a[i].num;

	}

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

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

	{

		cout<<a[i].k;

		if(i!=n)	cout<<' ';

		else	cout<<endl;

	}

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<cstring>

#include<cstdio>

#include<string>

#include<algorithm>

#include<cmath>

#include<cstdlib>

#include<iomanip>

#define llong long long

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

#define RF(i,a,n) for(register int i=a;i>=n;i--)

#pragma GCC optimize(2)

using namespace std;



const int maxn = 100005;

struct node{

	int idx, v;

	bool operator < (const node &b) const{

		return v < b.v;

	}

}a[maxn];



int n;



int main()

{

    ios::sync_with_stdio(false);

    cin>>n;

    For(i,1,n){

    	cin>>a[i].v;

    	a[i].idx = i;

    }

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

    For(i,1,n-1){

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

    }

    cout<<a[n].idx<<endl;

    return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include<algorithm>

using namespace std;

int n;



struct pairs{

	int id,number;

	bool operator<(const pairs& b) const{

		return number<b.number;

	}

}a[1000000];



int main(){

	cin>>n;

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

		a[i].id = i;

		cin>>a[i].number;

	}

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

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

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

	}

	cout<<a[n].id<<endl;

	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <cstdio>

#include <iostream>



using namespace std;



struct node

{

    int idx, p;

    bool operator<(const node &c)

    {

        return p < c.p;

    }

};



node x[200000];



int main()

{

    int N;

    scanf("%d", &N);

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

    {

        x[i].idx = i + 1;

        scanf("%d", &(x[i].p));

    }



    sort(x, x + N);

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

    {

        printf("%d ", x[i].idx);

    }

    printf("\n");

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

} 

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

#include <map>

#include <algorithm>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

using namespace std;

struct numble

{

	int xuhao;

	int shuzhi;

	numble(int a=0,int b=0)

	{

		xuhao=a; shuzhi=b;

	}	

};

numble t[100100];



bool judge(numble a,numble b)

{

	return a.shuzhi<b.shuzhi;

}

int main(int argc, char** argv) {

	int n;

	int tem;

	scanf("%d",&n);

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

	{

		scanf("%d",&tem);

		t[i]=numble(i+1,tem);

	}

	sort(t,t+n,judge);

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

	{

		printf("%d ",t[i].xuhao);

	}

	return 0;

}

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

#include<algorithm>

using namespace std;

#define MAXN 100010

struct S{

    int i;

    int A;

}s[MAXN];

bool cmp(S s1, S s2){

    return s1.A < s2.A;

}

int main(){

    int N;

    scanf("%d", &N);

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

        scanf("%d", &s[i].A);

        s[i].i = i;

    }

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

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

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

    printf("%d\n", s[N].i);

   // system("pause");

    return 0;

}

// Fastest known solution for this problem: