stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}




// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

	}

} 

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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<<' ';

	}

	

	

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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");

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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<<" ";

	}

} 

// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

 } 

// Optimized solution to the same problem (faster):
#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);

}

}

// 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<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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

} 


// Optimized solution to the same problem (faster):
#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);

}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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);

}

}

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

using namespace std;

#define ll long long int 

#define pi pair<int,int> 

#define pb push_back

#define INF INT_MAX 

#define mod 1000000007ll

#define fi first

#define se second

#define f(i,p,q) for(int i=p;i<q;i++)

#define si(a) scanf("%d",&a)

#define sii(a,b) scanf("%d %d",&a,&b)

#define siii(a,b,c) scanf("%d %d %d",&a,&b,&c)

#define pii(a) printf("%d\n",a)

#define psi(a) printf(" %d",a)

#define poi(a) printf("%d",a)

#define sl(a) scanf("%lld",&a)

#define pl(a) printf("%lld\n",a)

#define Nline() printf("\n")

#define sstr(str) scanf("%s",str)

#define pstr(str) printf("%s\n",str)

#define SET(a) memset(a,-1,sizeof(a))

#define CLR(a) memset(a,0,sizeof(a))

#define vi vector<int>

#define vvi vector<vi>

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

#define SORT(v) sort(all(v))

#define RSORT(v) sort(all(v), greater<int>())

#define VI(a,n) vi a(n); rep(i,n)cin>>a[i];

#define sq(n) (n)*(n)

#define iso ios::sync_with_stdio(false); cin.tie(0);cout.tie(NULL);

bool com(pair<int,int>p,pair<int,int>pp)

{

     return p.first<pp.first;

}

int main()

{  

    int n;

    cin>>n;

    vector<pair<int,int>>v;

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

    {

        int x;cin>>x;

        v.pb({x,i});

    }

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

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

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

}

// 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;

    map<int,int>mp;

    int a[n+1];

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

    {

        cin>>a[i];

        mp[a[i]]=i;

    }

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

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

        cout<<mp[a[i]]<<' ';

    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<bits/stdc++.h>

using namespace std;

#define ll long long int

ll ar[500009],br[500009],fr[500009];

string s1,s2;

map<string,int>mp;

int main()

{

    ll i,j,k,e,r,n,s,d,f,g,h,u,ck=0,ck1=0,t;

    cin >> n;

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

    {

        cin >> ar[i];

        stringstream ss;

        ss << ar[i];

        ss >> s2;

        mp[s2]=i;

    }

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

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

    {

        stringstream ss1;

        ss1 << ar[i];

        ss1 >> s1;

        cout << mp[s1] << " ";

    }

    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 <bits/stdc++.h>

#define Mod 1000000007

#define eps 1e-6

#define ll long long

#define INF 0x3f3f3f3f

#define MEM(x, y) memset(x, y, sizeof(x))

#define Maxn 1000000 + 10

using namespace std;

int n;

int h;

int result = 0;

map<ll,ll>id;

map<ll,ll>::iterator it;

int main()

{

    cin >> n;

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

    {

        int x;

        cin >> x;

        id[x]=i;

    }

    for(it=id.begin(); it!=id.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 <algorithm>

using namespace std;

struct student{

    int a;

    int b;

};

bool cmp(student a,student b){

    return a.a<b.a;

};

int main(){

    int n,i;

    cin >> n;

    student a[n];

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

        cin >> a[i].a;

        a[i].b=i+1;

    }

    sort(a,a+n,cmp);

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

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

    cout << a[n-1].b << 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):
/// However long the night,

///     The dawn will break

/// ICPC next year



#include<bits/stdc++.h>

using namespace std ;

const int N = 1e5+5 ;



int n ,x ;

pair<int,int> arr[N] ;

int main(){

    scanf("%d",&n);

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

        scanf("%d",&x);

        arr[i] = {x,i+1};

    }

    sort(arr,arr+n);

    for(int i=0;i<n;++i)printf("%d ",arr[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 <bits/stdc++.h>-



using namespace std;



int main()

{

    int n;

    cin>>n;

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

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

    {

        v[i].second=i;

        cin>>v[i].first;

    }

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

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

    {

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

    }

    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 <map>



using namespace std;



int main(){

    int N; cin >> N; map<int, int> M;

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

        int A; cin >> A; M.insert(make_pair(A, i+1));

    }



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

        if (i != M.begin()) cout << ' ';

        cout << (*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: