stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

#include<algorithm> 

using namespace std;

const int MAX=1e5+10;

struct student

{

	int num;

	int index;	

	bool operator<(const student &p) const

	{

		if(num!=p.num) return num<p.num;

	}

};

student a[MAX];

int main()

{

	int n=0;

	cin>>n;

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

	{

		cin>>a[i].num;

		a[i].index=i+1;

	}

	sort(a,a+n);

	cout<<a[0].index;

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

	cout<<endl;

	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<string.h>

#include<algorithm>

using namespace std;

int n;

struct A{

	int x;

	int y;

};

A a[100010];

bool cmp(A s,A d){

	return s.x<d.x;

}

int main(){

	cin>>n;

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

		cin>>a[i].x;

		a[i].y=i;

	}

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

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

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

		cout<<a[i].y;

	}

} 

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<algorithm>

using namespace std;

struct At{

	int index;

	int ai;

}a[100010];

bool cmp(At a,At b){

	return a.ai<b.ai;

}

int main(){

	int n;

	cin>>n;

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

		cin>>a[i].ai;

		a[i].index=i;

	}

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

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

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

	}

	cout<<endl;

	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<algorithm>

using namespace std;



int N;

struct st{

	int i,a;

} A[100010];

bool cmp(const st &x, const st &y){

	return x.a<y.a;

}



int main(void){

	cin>>N;

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

		cin>>A[i].a;

		A[i].i=i;

	}

	sort(A,A+N,cmp);

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

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

	cout<<endl;



	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <algorithm>

using namespace std;

const int maxn=1e5+10;

int n;

struct node{

	int val,idx;

	bool operator<(const node &t){

		return val<t.val;

	}

}a[maxn];

int main()

{

	scanf("%d",&n);

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

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

		a[i].idx=i;

	}

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

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

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

	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include <algorithm>

using namespace std;

struct A{

    int ai;

    int i;

}a[100005];

bool cmp(A a, A b) {

    return a.ai < b.ai;

}

int main() {

    int N;

    cin >> N;

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

        cin >> a[i].ai;

        a[i].i = i;

    }

    sort(a, a + N, cmp);

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

        cout << a[i].i + 1 << ' ';

    return 0;

}


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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include <climits>

#include <cmath>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <iostream>

#include <list>

#include <map>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <vector>



struct N{

    int a, b;

    inline bool friend operator<(const N& a, const N& b) {

        return a.b < b.b;

    }

}a[100010];

int main() {

    int n;

    std::cin >> n;

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

        std::cin >> a[i].b;

        a[i].a = i;

    }

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

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

        std::cout << a[i].a << " ";

    }

    return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<cstdio>

#include<cstdlib>

#include<cmath>

#include<cstring>

#include<algorithm>

#include<queue>

#define LL long long

#define inl inline

#define re register

#define MAXN 100100

using namespace std;

int n;

struct cc

{

	int a,i;

	bool operator<(const cc& b)

	{

		return a<b.a;

	}

}s[MAXN];

int main()

{

	scanf("%d",&n);

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

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

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

	cout<<"\n";

	

	return 0;

}




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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<cstdlib>

#include<vector>

#include<map>

#include<algorithm>

#define inf 0x3f3f3f3f

const int maxn= 1e5+5;

using namespace std;

struct stu{

	int num,a;

	bool operator<(stu& b)const{

		return a<b.a;

	}

}students[maxn];

int n;

int main(){

	std::ios::sync_with_stdio(false);

	cin>>n;

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

		cin>>students[i].a;

		students[i].num=i;

	}

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

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

		cout<<students[i].num<<' ';

	}

	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include <algorithm>

const int N = 1e5 + 5;

using namespace std;



struct Node

{

	int index;

	int a;

}node[N];



bool cmp(const Node& a, const 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].index = i;

	}



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



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

	{

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

	}



	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include <algorithm>

#include <vector>

using namespace std;



struct node {

	int num;

	int value;

	bool operator < (const node & P){

		if(value !=  P.value){

			return value < P.value;

		}

		return true;

	}

};

vector<node> v;

int main(){

	int n;

	cin>>n;

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

		node nd;

		nd.num = i;

		cin>>nd.value;

		v.push_back(nd);

	}

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

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

		if(!i)cout<<v[i].num;

		else cout<<" "<<v[i].num;

	}

} 

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<vector>

#include<algorithm>

using namespace std;



struct node {

	int mingci;

	int renshu;

	

	node(int m,int r) {

		mingci=m;

		renshu=r;

		

	}

	bool operator < (const node &a) {

		return renshu<a.renshu;

	}

}; 



int N;

vector<node> vec;

int main() {

	cin>>N;

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

		int temp;

		cin>>temp;

		vec.push_back(node(i,temp));

	}

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

	

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

		cout<<vec[i].mingci<<' ';

	}

	

	

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<algorithm>

#include<cstdio> 



using namespace std;



struct node

{

	int x,y;

	bool operator <(const node &a)

	{

		return x<a.x;

	}

};



node a[100010];



int main()

{

	int n;

	scanf("%d",&n);

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

	{

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

		a[i].y=i+1;

	}

	sort(a,a+n);

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

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

	

	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include<algorithm>

using namespace std;

struct People

{

	int id1;

	int value;

	bool operator<(const People&p)const

	{

		return id1<p.id1;

	}

}A[100005];

int main()

{

	int N;

	cin>>N; 

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

	{

		cin>>A[i].id1;

		A[i].value=i;

	}

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

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

	{

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

	}

	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

	int N; scanf("%d", &N);

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

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

		A[i].b = i;

	}

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

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

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

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include<algorithm>

using namespace std;



struct stu

{

	int index;

	int a;



	bool operator<(const struct stu&t)const

	{

		return a < t.a;

	}

}b[100010];

int main()

{

	int n;

	cin >> n;

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

	{

		int x;

		cin >> x;

		b[i].a = x;

		b[i].index = i;



	}

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



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

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

	cout << endl;

	//system("Pause");

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include <algorithm>

using namespace std;



int n;

struct stu

{

	int a;

	int b;

}s[100010];



int cmp(stu& x, stu& y)

{

	return x.a < y.a;

}



int main()

{

	cin >> n;

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

	{

		cin >> s[i].a;

		s[i].b = i;

	}

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

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

	{

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

	}

	return 0;

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include<algorithm>

using namespace std;

struct node{

	int i,num;

}A[110000];

bool cmp(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,cmp);

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

	{

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

	}

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include<algorithm>

using namespace std;

struct stu{

	int number,rank;

	bool operator < (const stu s)

	{

		return rank<s.rank;

	}

};

stu ss[100010];

int main()

{

	int n;

	cin>>n;

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

	{

		ss[i].number=i;

		cin>>ss[i].rank;

	}

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

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

	{

		cout<<ss[i].number;

		if(i!=n)

			cout<<" ";

	}

	cout<<endl;

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include<iostream>

#include<algorithm>

using namespace std;

struct student{

	int i;

	int rank;

	bool operator < (const student& e)const{

		if(rank!=e.rank){

			return rank<e.rank;

		}

		return true;

	} 

}a[100010];

int main()

{

	int n;

	scanf("%d",&n);

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

		a[i].i=i;

		cin>>a[i].rank;

	}

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

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

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

	}

	return 0;

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

using namespace std;

struct S{

    int num,Ai;

}a[100010];

bool cmp(S A,S B){

    return A.Ai<B.Ai;

}

int main() {

    int n;

    cin>>n;

    for(int i=1;i<=n;i++)   cin>>a[i].Ai,a[i].num=i;

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

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

    return 0;

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

using namespace std;



int n;

struct node

{

	int num;

	int t;

} a[100005];



inline int cmp(node x,node y)

{

	if(x.t < y.t)return 0;

	else return 1;

}



int main()

{

	cin>>n;



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

		a[i].num = i,cin>>a[i].t;



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



	for(int i=n; i>=1; i--)

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



	return 0;

}

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

#include<algorithm>

#include<cstdio>

#define N 100005

using namespace std;

struct ab{

int a,b;

};

ab a[N];

int cmp(ab x,ab y){

return x.a<y.a;

}

int n;

int main(){

scanf("%d",&n);

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

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

a[i].b=i;

}

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

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

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

}

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

using namespace std;



struct node{

	int id,rank;

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

	bool operator <(const node& rhs) const {

		return rank>rhs.rank;

	}

};



priority_queue<node> Q;

int n,x,y;



int main(){

	scanf("%d",&n);

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

		scanf("%d",&x);

		Q.push(node(i,x));

	}

	while(!Q.empty()){

		printf("%d ",Q.top());Q.pop();

	}

}

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

#include<algorithm>

#include<cstdio>

#define N 100005

using namespace std;

struct ab{

int a,b;

};

ab a[N];

int cmp(ab x,ab y){

return x.a<y.a;

}

int n;

int main(){

scanf("%d",&n);

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

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

a[i].b=i;

}

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

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

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

}

}
// Slower C++ solution:
#pragma GCC optimize ("O3")

#include <bits/stdc++.h>

#define ll long long

#define cst first

#define dur second

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

using namespace std;

const int N = 1e5 + 5, M = 2 * N + 5;





int main(){

    int n;

    scanf("%d", &n);

    vector<pair<int, int> > v;

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

        int x;

        scanf("%d", &x);

        v.emplace_back(x, i);

    }

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

    for(auto i : v)printf("%d ", i.second);

}

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

#include<algorithm>

#include<cstdio>

#define N 100005

using namespace std;

struct ab{

int a,b;

};

ab a[N];

int cmp(ab x,ab y){

return x.a<y.a;

}

int n;

int main(){

scanf("%d",&n);

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

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

a[i].b=i;

}

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

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

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

}

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



using namespace std;



int main()

{

	long long n;

	cin>>n;

	long long arr[n];

	vector< pair<long long,long long> >v;

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

	{

		cin>>arr[i];

		v.push_back(make_pair(arr[i],i+1));

	}

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

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

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

}


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

#include<algorithm>

#include<cstdio>

#define N 100005

using namespace std;

struct ab{

int a,b;

};

ab a[N];

int cmp(ab x,ab y){

return x.a<y.a;

}

int n;

int main(){

scanf("%d",&n);

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

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

a[i].b=i;

}

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

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

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

}

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

using namespace std;



int main( )

{

    int n, i, j, k;

    vector< pair<int, int> > v;

    cin >> n;

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

        cin >> j;

        v.push_back(make_pair(j, i));

    }

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

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

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

        cout << v[i].second;

    }

    cout << '\n';

    return 0;

}


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

#include<algorithm>

#include<cstdio>

#define N 100005

using namespace std;

struct ab{

int a,b;

};

ab a[N];

int cmp(ab x,ab y){

return x.a<y.a;

}

int n;

int main(){

scanf("%d",&n);

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

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

a[i].b=i;

}

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

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

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

}

}