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

#include<algorithm>

using namespace std;

int n,m;

struct node{

	int v,n;

}a[100005];

int cmp(node a,node b)

{

	return (a.n<b.n);

}

int main()

{

	cin >> n;

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

	{

		cin >>m;

		a[i].v=i;

		a[i].n=m;

	}

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

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

	{

		if(i==1)

		cout << a[i].v;

		else

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

	}

	cout <<endl;

}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include <cmath>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <fstream>

#include <functional>

#include <iostream>

#include <map>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <string>

#include <vector>

#define LL long long

using namespace std;

inline int get_num() {

    char c;

    int f = 1, num = 0;

    while ((c = getchar()) == ' ' || c == '\n' || c == '\r')

        ;

    if (c == '-')

        f = -1;

    else

        num = c - '0';

    while (isdigit(c = getchar())) num = num * 10 + c - '0';

    return num * f;

}

const int MAXN = 1e5 + 7;

struct re {

    int a, b;

    bool operator<(const re &a) const { return b < a.b; }

} v[MAXN];

int main() {

    int n;

    cin >> n;

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

        v[i].a = i;

    }

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

        cin >> v[i].b;

    }

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

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

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

    }

    return 0;

}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include<algorithm>

using namespace std;

struct as

{

	int number;

	int muq;

};

bool cmp(as& a,as& b)

{

	return a.muq<b.muq;

}

as a[100010];

int main()

{

	int n;cin>>n;

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

	{

		cin>>a[i].muq;

		a[i].number=i;

		//1 2

		//2 3

		//3 1

	}

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

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

	{

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

	}

	return 0;

 } 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include<stdio.h>

#include<stdlib.h>

#include <algorithm>

using namespace std;

const int maxn=1e5+10;

int N,A;

struct node

{

	int index,value;

}a[maxn];

bool cmp(node &a,node &b)

{

	return a.value<b.value ;

}

int main()

{

	cin>>N;

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

	{

		cin>>A;

		a[i].index=i;

		a[i].value=A;

	}

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

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

	{

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

	}

	return 0;

 } 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include <cstdio>

#include <algorithm>

#define N 100010

using namespace std;

struct node{

	int id,num;

}a[N];

bool cmp(const node&a1,const node&a2){

	return a1.num<a2.num;

}

int main(){

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

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

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

		a[i].id=i;

	}

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

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

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

	return 0;

}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include<algorithm>

#include<string>



using namespace std;

struct node{

	int i;

	int sum;

};



node A[100010];

bool cmp(node a,node b){

	return a.sum<b.sum;

}



int main(){

	int n;cin>>n;

    for(int i=1;i<=n;i++)cin>>A[i].sum,A[i].i=i;

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

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

	

	

	

	

	return 0;

} 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include<algorithm>

using namespace std;

const int maxn=100010;  //100010

int n;

struct s{

	int i,ai;

	s(){

		this->ai=this->i=0;

	} 

}a[maxn];

bool cmp(const s &a,const s &b)

{

	//if(a.b==b.b) return a.a<b.a;

	return a.ai<b.ai; 

}

int main()

{

	scanf("%d",&n);

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

	{

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

			a[j].i=j;

	}

	 sort(a,a+n,cmp);

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

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

	return 0;

 } 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

using namespace std;

const int mx = 1E5 + 10;

struct node

{

    int id;

    int dat;

};

node s[mx];



bool cmp(node s1, node s2)

{

    return s1.dat < s2.dat;

}



int main()

{

    int n;

    cin >> n;

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

    {

        s[i].id = i;

        cin >> s[i].dat;

    }

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

    cout << s[1].id;

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

    {

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

    }

    cout << endl;

    return 0;

}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include<algorithm>

#include<cmath>

using namespace std;

struct student

{

	int i;

	int ai;

};

student stu[100010];



bool cmp(student& a, student& b)

{

	return a.ai < b.ai;

}



int main()

{

	int n;

	cin >> n;

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

	{

		stu[i].i = i + 1;

		cin >> stu[i].ai;

	}

	sort(stu, stu + n, cmp);

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

	{

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

	}

}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include <stdlib.h>

#include <string>

#include <math.h>

#include <algorithm>

using namespace std;

const int N=100500;

pair<int,int> a[N];

int main()

{

	int n;

	cin>>n;

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

	{

		cin>>a[i].first;

		a[i].second=i+1;

	 } 

	sort(a,a+n);

	cout<<a[0].second;

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

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

	return 0;

 } 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	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>

#define ll long long

using namespace std;

struct re

{

    int a;

    int id;

}p[100005];

bool cmp(re x,re y)

{

    return x.a < y.a;

}

int main()

{

    int n;

    cin>>n;

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

    {

        int x;

        cin>>x;

        p[i].id =  i;

        p[i].a = x;

    }

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

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

    {

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

    }

    return 0;

}


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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include <algorithm>

#include <iostream>

#include <bitset>

#include <set>

#include <sstream>

#include <string>

#include <cstring>

#include <stack>

#include <cmath>

#include <queue>

#include <cctype>

#include <map>

#include <cstdlib>

#include <vector>

#define ll long long

#define INF 0x3f3f3f3f

using namespace std;



ll read(){

    ll x=0,f=1;char ch=getchar();

    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}

    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}

    return x*f;

}



int n;

struct info{

    int id,num;

}a[100005];

bool cmp(info x,info y){

    return x.num<y.num;

};





int main() {

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

    n = read();

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

        a[i].num=read();

        a[i].id=i;

    }

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

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

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



}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include<algorithm>

using namespace std;

int n;

pair<int, int> a[100005];

int main ()

{

	cin>>n;

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

	{

		cin>>a[i].first;

		a[i].second=i;

	}

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

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

	{

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

		cout<<a[i].second;

	}

	cout<<endl;

	return 0;

}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include <algorithm> 

using namespace std;



struct node

{

	int index;

	int ai;

};



bool cmp(node a,node b)

{

	return a.ai<b.ai;

}



int main()

{

	int n;

	cin>>n;

	node stu[n+1];

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

	{

		cin>>stu[i].ai;

		stu[i].index=i;

	}

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

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

	{

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

	}

	cout<<endl;

	

} 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include <algorithm>

using namespace std;



int n;

struct per

{

	int idx;

	int cnt;

	

	bool operator < (const per& t) const

	{

		return cnt<t.cnt;

	}

}p[500010];



int main()

{

	cin>>n;

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

	{

		cin>>p[i].cnt;

		p[i].idx=i;

	}

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

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

	{

		if(i!=n)

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

		else

			cout<<p[i].idx<<"\n";	

	}	

	

	return 0;

}

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

using namespace std;

int n;

map<int,int>per;

int main()

{

	scanf("%d",&n);

	int rnk=0;

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

		scanf("%d",&rnk);

		per[rnk]=i+1;

	}

	int cnt=0;

	for(map<int,int>::iterator i=per.begin();i!=per.end();i++){

		if(cnt++) printf(" ");

		printf("%d",i->second);

	}

	return 0;

} 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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

#include<algorithm>

using namespace std;

struct stu

{

	int idx;

	int tol;

	bool operator<(const stu s) const

	{

		return tol<s.tol;

	}

};

const int sz=1e5+10;

stu stud[sz]; 

int main(void)

{

	int N;

	cin>>N;

	for(int i=1;i<=N;i++)		//从1开始 

	{

		stud[i].idx=i;

		cin>>stud[i].tol;

	} 

	sort(stud+1,stud+N+1);		//排完序

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

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

	cout<<endl; 

	return 0;

} 

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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

}
// Slower C++ solution:
//

//  main.cpp

//  lab1

//

//  Created by 王黎杉 on 2020/5/29.

//  Copyright © 2020 王黎杉. All rights reserved.

//



#include <algorithm>

#include <vector>

#include <iostream>

using namespace std;



vector<pair<int,int>> classroom;



bool cmp(pair<int,int> &a,pair<int, int> &b)

{

    return a.second < b.second;

}



int main()

{

    ios::sync_with_stdio(false);

    

    int n = 0,a = 0;

    

    cin>>n;

    

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

    {

        cin>>a;

        classroom.push_back(make_pair(i,a));

    }

    

    sort(classroom.begin(), classroom.end(), cmp);

    

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

    {

        cout<<classroom[i].first<<" ";

    }

    

    

    return 0;

}


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

#include<algorithm>

using namespace std;



struct person{

	int id;

	int num;

	bool operator < (const person& p)const {

        return num<p.num;

    }

};



int N=0;

person a[100010];



int main(){

	scanf("%d",&N);

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

		a[i].id=i;

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

	}

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

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

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

	}

	printf("%d",a[N]);

	return 0;

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



using namespace std;



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

#define ll long long

#define endl '\n'



int main()

{

	int n,a[100005];

	map<int,int>m;

	cin >>n;

	

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

	{

		cin >> a[i];

		m.insert({a[i],i});

	}

	vector<int>v;

	for(auto it : m)

	{

		v.push_back(it.second);

	} 

	

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

	{

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

	}

	cout << v[n-1] << endl;

	return 0;

}


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

}

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;

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

typedef long long ll;

using namespace std;

 

const int N = 1e5 + 10 , M = 5e5+10 ,  MOD = 1e9+7;

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

#define clr(arr,val) memset(arr , val , sizeof (arr))

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

#define rloop(i,n) for(int i = int(n)-1;i >= 0;i--)

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

#define ALL(v) ((v).begin()) , ((v).end())

#define SZ(v)  ((int)((v).size()))

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

int dx[]={1,0,-1,0};int dy[]={0,1,0,-1}; //4 Direction

//int dx[]={1,1,0,-1,-1,-1,0,1};int dy[]={0,1,1,1,0,-1,-1,-1};//8 direction

//int dx[]={2,1,-1,-2,-2,-1,1,2};int dy[]={1,2,2,1,-1,-2,-2,-1};//Knight Direction

//int dx[6]={2,1,-1,-2,-1,1};int dy[6]={0,1,1,0,-1,-1}; //Hexagonal Direction

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

//freopen("output.txt", "w", stdout);

 







int n ;



 

int main()

{

	

   // ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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



using namespace std;

const int N = 2e5+5;

pair<int,int> v[N];

int main()

{

    int n;

    cin >> n;

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

    {

        cin >> v[i].first;

        v[i].second = i;

    }

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

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

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

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

typedef long long ll;

using namespace std;

 

const int N = 1e5 + 10 , M = 5e5+10 ,  MOD = 1e9+7;

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

#define clr(arr,val) memset(arr , val , sizeof (arr))

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

#define rloop(i,n) for(int i = int(n)-1;i >= 0;i--)

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

#define ALL(v) ((v).begin()) , ((v).end())

#define SZ(v)  ((int)((v).size()))

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

int dx[]={1,0,-1,0};int dy[]={0,1,0,-1}; //4 Direction

//int dx[]={1,1,0,-1,-1,-1,0,1};int dy[]={0,1,1,1,0,-1,-1,-1};//8 direction

//int dx[]={2,1,-1,-2,-2,-1,1,2};int dy[]={1,2,2,1,-1,-2,-2,-1};//Knight Direction

//int dx[6]={2,1,-1,-2,-1,1};int dy[6]={0,1,1,0,-1,-1}; //Hexagonal Direction

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

//freopen("output.txt", "w", stdout);

 







int n ;



 

int main()

{

	

   // ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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



using namespace std;



int main()

{

    int n  , x;

    cin >> n;

    int arr[n];

    vector< pair<int,int> >vp;

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

    {

        cin >> x;

        vp.push_back({x,i+1});

    }

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

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

    {

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

    }

    cout << "\n";

    return 0;

}