stablegradients/pie-gem5-pairs huggingface dataset:
// 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.219539931780037x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.171025684608037x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.225866910705117x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.219512242297361x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.220305193070856x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.2199501840417435x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.140623888157836x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.22749672179939x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.22850151747527x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.219286043655795x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.177293314384588x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.22603175813997x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	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.303331428210961x):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

	for(int i=0;i<n;i++) printf("%d ",st[i].flag);

	return 0;	

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

#include<iostream>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace  std;

struct node

{

	int a,b;

}edge[101010];

bool cmp(node x,node y)

{

	return x.a < y.a;

}

int n;

int main()

{

	cin>>n;

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

	{

		cin>>edge[i].a;

		edge[i].b=i;

	}

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

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

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

	

	return 0;

}








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

struct siswa{

	int idx;

	int num;

};

bool cmp(siswa a,siswa b){

	return a.num<b.num;

}

int main(){

	int n;cin>>n;vector<siswa>v;

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

		int a;cin>>a;siswa tmp;tmp.idx=x+1;tmp.num=a;v.push_back(tmp);

	}

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

	cout<<v[0].idx;

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

		cout<<" "<<v[x].idx;

	}

	cout<<endl;

}

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

the top of the losers

*/

#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

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

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

#define  allr(v)    ((v).rbegin()),((v).rend())

#define   pb         push_back

#define   mp         make_pair

#define    Lcm(a,b)  ((a*b)/(__gcd(a,b)))

#define   length(a)      hypot( (a.imag()),(a.real()) )

#define    x            real()

#define    y            imag()

#define    clr(v,d)      memset( v, d ,sizeof(v))

#define     point        complex<double>

#define    dp(a,b)          (((conj(a))*(b)).real())

#define    cp(a,b)          (((conj(a))*(b)).imag())

typedef  long long     ll ;

typedef  unsigned long long     ull ;

const double eps= (1e-9);

using namespace std;

using namespace __gnu_pbds;

int dcmp(long double a,long double b){   return fabsl(a-b)<=eps ? 0: (a>b)? 1:-1  ;}

int countNumBit1(int mask) {int ret=0; while (mask) 	{mask &= (mask-1);++ret;	}return ret;}

void GO(){ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);}

vector< pair<int,int> > v;

int main(){

    GO();

    int n;

    cin>>n;

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

        int no;

        cin>>no;

        v.pb(mp(no,i+1));

    }

    sort(all(v));

    for(int i=0;i<sz(v);i++){

        if(i==0)

        cout<<v[i].second;

        else

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

    }

    cout<<endl;

}


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

#include<algorithm>

using namespace std;

int n;

struct lxs

{

	int t,x;

}st[100010];

bool cmp(lxs a,lxs b)

{

	return a.t<b.t;

}

int main()

{

	scanf("%d",&n);

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

	{

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

		st[i].x=i;

	}

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

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

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

	return 0;

}

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

{ 

    

    vector< pair <int,int> > vect; 

    int n,t;

    cin>>n; 

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

    {

        cin>>t;

        vect.push_back( make_pair(t,i) ); 

    }

    



    

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



   

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

    { 

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

    } 



    return 0; 

} 




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

  int n; cin >> n;

  vector <int> a(n), ord(n);

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

    cin >> a[i];

    ord[i] = i;

  }

  auto comp = [&] (int x, int y) {

    return a[x] < a[y];

  };

  sort(ord.begin(), ord.end(), comp);

  for(auto x : ord) cout << x + 1 << ' ';

}

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



typedef long long ll;

int ara[60];

int main()

{

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

    vector< pair <int, int> > pii;

    int n;

    cin>>n;

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

    {

        int a;

        cin>>a;

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

    }

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

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

    {

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

    }

    cout<<endl;

    return 0;

}

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

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

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

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

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

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

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

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

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

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

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

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

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v,v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    string s;

    cin>>n;

    FOR(i,n)

    {

        cin>>a;

        vp.p_b(m_p(a,i+1));

    }

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

    FOR(i,n) cout<<vp[i].ss<<" ";

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


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

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;

using namespace std;

#define mp make_pair

#define pb(x) push_back(x)

#define vi vector<int>

#define vs vector<string>

#define vll vector<long long>

#define vc vector<char>

#define vs vector<string>

#define pii pair<int, int>

#define pll pair<long long, long long>

#define pil pair<int, long long>

#define pli pair<long long, int>

#define pcc pair<char, char>

#define pdd pair<double, double>

#define mll map<long long, long long>

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

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

#define flsh fflush(stdout)

#define gcd __gcd

#define clr(x) memset(x, 0, sizeof(x))

#define mod 1000000007LL

#define mod2 998244353LL

#define INF 1000000000007

 



typedef long long ll;

typedef long double ld;

typedef unsigned long long ull;

typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> o_tree;





void solve()

{

   ll n;

   cin>>n;

   pll p[n];

   ll i,j;

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

   {

       cin>>p[i].first;

       p[i].second=i+1;

   }

   sort(p,p+n);

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

   {

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

   }

   cout<<"\n";



}





int main()

{

ios_base::sync_with_stdio(false);

cin.tie(NULL);





if (fopen("input.txt","r" ))

  {

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

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

  }

cout<<setprecision(20);





ll t=1;





// cin>>t;





while(t--)

{

solve();

} 





return 0;

}

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

}