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

#include<iostream>

#include<algorithm>

#include<cstring>



using namespace std;



struct peo

{

	int id,num;

}p[101000];

bool cmp(peo a,peo b)

{

	return a.id<b.id;

}

int main()

{

	int n;cin>>n;

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

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

	for(int i=1;i<=n;i++) printf("%d ",p[i].num);

	return 0;

}

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

#include <map>

using namespace std;

map<int,int> m;



int main()

{

	int n,a;

	cin>>n;

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

		cin>>a;

		m[a]=i;

	}

	map<int,int>::iterator it;

	for(it=m.begin();it!=m.end();it++) cout<<it->second<<" ";

	return 0;

}

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

#include<algorithm>

using namespace std;





struct Node{

	int a;

	int b;

};



int n;

Node f[100003];

bool cmp(Node a, Node b){

	if(a.b < b.b) return true;

	return false;

}



int main(){	

	cin >> n;

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

		cin >> f[i].b;

		f[i].a = i;

	}

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

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

	return 0;

}

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

#include<vector>

#include<string>

#include<algorithm>

using namespace std;

const int nmax=1e5+10;

int main(){

	int n;

	scanf("%d",&n);

	vector<pair<int,int> > ans;

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

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

		ans.push_back(make_pair(tmp,i));

	}

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

	for(auto it=ans.begin();it!=ans.end();it++){

		printf(it==ans.begin()?"%d":" %d",it->second);

	}

	return 0;

}

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

#include<algorithm>

using namespace std;



struct stu

{

	int num;

	int order;

	bool operator <(const stu&s)

	{

		return num<s.num;

	}

}a[100099];

 

int main()

{

	int n;

	cin>>n;

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

	{

		cin>>a[i].num;

		a[i].order=i+1;

	}

	sort(a,a+n);

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

	{

		cout<<a[i].order<<' ';

	}

	cout<<endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.2298106626772345x):
#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<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.231485029102439x):
#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<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.223425646681249x):
#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<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.232974513040921x):
#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<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.23281024096181x):
#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 <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.161372157410545x):
#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 <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.222846925450084x):
#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 <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.223589918760361x):
#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<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.18657114800989x):
#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<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.29259010007762x):
#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 <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.223862641649865x):
#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 <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.239021647379355x):
#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<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.23736755181633x):
#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<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.161196714286781x):
#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 <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.421095040803174x):
#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<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.223536474309653x):
#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<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");

}

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

}

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

	}

} 

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

 } 

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

#include <cstring>

#include <string>

#include <cmath>

#include <algorithm>

#include <vector>

#include <cstdio>

using namespace std;

int n;

struct stu

{

	int k;

	int num;

	bool operator<(const stu &a)const

    {

        return num < a.num;

    }



}a[100010];

int main()

{	

    cin>>n;

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

    {

    	a[i].k = i;

    	cin>>a[i].num;

	}

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

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

	{

		cout<<a[i].k;

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

		else	cout<<endl;

	}

    return 0;

}


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

} 


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

}


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

}

}