stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#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;

}


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

}
// Slower C++ solution:
#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;

} 

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

}
// Slower C++ solution:
#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;

}

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

}
// Slower C++ solution:
#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");

}

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

}
// Slower C++ solution:
#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;

}

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

}
// Slower C++ solution:
#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;

}

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

}
// Slower C++ solution:
#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;

}

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

}
// Slower C++ solution:
#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;

} 

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

}
// Slower C++ solution:
#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;

}

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

}
// Slower C++ solution:
#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;

}


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

}
// Slower C++ solution:
#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;

}


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

}
// Slower C++ solution:
#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;

}

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

}
// Slower C++ solution:
#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;

}

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

}
// Slower C++ solution:
#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");

}

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

}
// Slower C++ solution:
#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;

}

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

#include<algorithm>

using namespace std;



struct STU{

	int id;

	int num;

	bool operator<(const STU&s)const{

		return num<s.num;

	}

}a[100005];



int n;



int main(){

	scanf("%d",&n);

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

		int sp;

		scanf("%d",&sp);

		a[i].id=i;

		a[i].num=sp;

	}

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

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

		if(i!=1)printf(" ");

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

	}

	printf("\n");

}
// Slower C++ solution:
#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;

}

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



#define mem(f, v) memset(f,v,sizeof(f))

#define file(x) freopen(x".in","r",stdin);freopen(x".out","w",stdout);



typedef long long ll;

const int maxn = 100010;

const int inf = ~(1u << 31u);

const ll linf = ~(1llu << 63u);



using namespace std;



int main() {

    ios::sync_with_stdio(false);

    int n;

    cin >> n;

    vector<pair<int, int>> d(n);

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

        cin >> d[i].first;

        d[i].second = i+1;

    }

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

    for(auto x:d) cout << x.second << " \n"[x.first == (*d.rbegin()).first];

    return 0;

}
// Slower C++ solution:
#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;

}

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

#include<algorithm>

using namespace std;

struct node{

	int i,num;

}A[110000];

bool comp(node a,node b)

{

	return a.num<b.num;

}

int main()

{

	int N;

	cin>>N;

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

	{

		int t;

		cin>>t;

		A[i].i=i;

		A[i].num=t;

	}

	sort(A+1,A+N+1,comp);

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

	{

		cout<<A[i].i<<" ";

	}

}
// Slower C++ solution:
#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;

}

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

#include <cstring>

#include<algorithm>

using namespace std;

int n;

struct person

{

	int i;

	int Ai;

}p[100005];



bool cmp(person&p1,person&p2)

{

	return p1.Ai<p2.Ai;

}



int main()

{

	cin>>n;

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

	{

		p[j].i=j;

		cin>>p[j].Ai;

	}

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

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

	{

		cout<<p[j].i<<" ";

	}

 }
// Slower C++ solution:
#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;

}

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

#include<algorithm>

using namespace std;



struct stu

{

	int ind;

	int num;

}s[100005];



bool cmp(stu&s1,stu&s2)

{

	return s1.num < s2.num;

}



int main()

{

	int N;

	cin >> N;

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

	{

		s[i].ind = i;

		cin >> s[i].num;

	}

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

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

	{

		cout << s[i].ind <<" ";

	}

}
// Slower C++ solution:
#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;

}

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

#include <algorithm>

using namespace std;



const int Max=1e5+1;

int a[Max];



struct stu

{

    int id,tal;

    bool operator <(const stu& st)  const

	{

        return tal<st.tal;

    }

}s[Max];



int main()

{

	int n;

    cin>>n;

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

    {

        cin>>a[i];

        s[i].id=i;

        s[i].tal=a[i];

    } 

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

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

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

    return 0;

}
// Slower C++ solution:
#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;

}

// Faster C++ solution for the same problem (measured speedup: 1.7777015636612437x):
/*

    Author: Alam Khan

    AUST CSE 40th Batch



*/



#include<bits/stdc++.h>

using namespace std;

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

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

using namespace __gnu_pbds;



typedef long long ll;

typedef pair<ll,ll> pll;

typedef vector<ll> vl;

typedef deque<ll> dl;

typedef stack<ll> stl;

typedef set<ll> sl;

typedef map<string, ll> msl;

typedef map<ll,ll> mll;

typedef tree<ll,null_type,less_equal<ll>,rb_tree_tag,tree_order_statistics_node_update>ordered_set;

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

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

#define sfff(n,m,r)     scanf("%lld %lld %lld",&n,&m,&r)

#define sfs(n)     scanf("%s",n)

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

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

#define pfff(n,m,r)     printf("%lld %lld %lld\n",n,m,r)

#define pfs(n)     printf("%s\n",n)

#define pfcs(i,n)     printf("Case %lld: %lld\n",i,n)

#define pb     push_back

#define prf     printf

#define inf     2e18

#define low     -1000000000000

#define PI        acos(-1.0)

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

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

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

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

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

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

#define endl  "\n"

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

#define fr freopen("input.txt","r",stdin)

#define fw freopen("output.txt","w",stdout)



int main()

{

    ll i,n,t,k,j,x=0,y=0,m;

    vector<pair<ll,ll> > v;

    cin>>n;

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

    {

        cin>>x;

        v.pb({x,i});

    }

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

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

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

    cout<<endl;

    return 0;

}
// Slower C++ solution:
#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;

}

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

}