stablegradients/pie-gem5-pairs huggingface dataset:
// 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.7831218145671497x):
#include<bits/stdc++.h>

using namespace std;

#define ff first

#define ss second



int main()

{

    int n, i;



    cin >> n;



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



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

    {

        cin >> v[i].ff;

        v[i].ss = i+1;

    }



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



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

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

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

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

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

using namespace std;

#define ff first

#define ss second



int main()

{

    int n, i;



    cin >> n;



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



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

    {

        cin >> v[i].ff;

        v[i].ss = i+1;

    }



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



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

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

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

using namespace std;



int n;

struct node

{

	int num;

	int t;

} a[100005];



inline int cmp(node x,node y)

{

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

	else return 1;

}



int main()

{

	cin>>n;



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

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



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



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

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



	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.214921282288236x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

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

using namespace std;



struct node{

	int id,rank;

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

	bool operator <(const node& rhs) const {

		return rank>rhs.rank;

	}

};



priority_queue<node> Q;

int n,x,y;



int main(){

	scanf("%d",&n);

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

		scanf("%d",&x);

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

	}

	while(!Q.empty()){

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

	}

}

// Faster C++ solution for the same problem (measured speedup: 5.208950350163305x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

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

#include <bits/stdc++.h>

#define ll long long

#define cst first

#define dur second

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

using namespace std;

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





int main(){

    int n;

    scanf("%d", &n);

    vector<pair<int, int> > v;

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

        int x;

        scanf("%d", &x);

        v.emplace_back(x, i);

    }

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

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

}

// Faster C++ solution for the same problem (measured speedup: 5.209895489533477x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

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



using namespace std;



int main()

{

	long long n;

	cin>>n;

	long long arr[n];

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

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

	{

		cin>>arr[i];

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

	}

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

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

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

}


// Faster C++ solution for the same problem (measured speedup: 5.267419284050232x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

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

using namespace std;



int main( )

{

    int n, i, j, k;

    vector< pair<int, int> > v;

    cin >> n;

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

        cin >> j;

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

    }

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

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

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

        cout << v[i].second;

    }

    cout << '\n';

    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.270114180524772x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.215085365453042x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.234035004702305x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.216351721349359x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.209192033816591x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.221637741867145x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.22330949166527x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.215262704096658x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

}
// 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.224796647902989x):
//#define _CRT_SECURE_NO_WARNINGS

#include<cstdio>

#include<algorithm>



struct people {

	int tag, num;

	bool operator<(const people& p) const {

		return num < p.num;

	}

}A[100005];



int main() {

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

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

		A[i].tag = i + 1;

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

	}

	std::sort(A, A + N);

	printf("%d", A[0].tag);

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

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

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

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

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

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

using namespace std;



int n;

struct node

{

	int num;

	int t;

} a[100005];



inline int cmp(node x,node y)

{

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

	else return 1;

}



int main()

{

	cin>>n;



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

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



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



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

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



	return 0;

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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

using namespace std;



struct node{

	int id,rank;

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

	bool operator <(const node& rhs) const {

		return rank>rhs.rank;

	}

};



priority_queue<node> Q;

int n,x,y;



int main(){

	scanf("%d",&n);

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

		scanf("%d",&x);

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

	}

	while(!Q.empty()){

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

	}

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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

#include <bits/stdc++.h>

#define ll long long

#define cst first

#define dur second

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

using namespace std;

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





int main(){

    int n;

    scanf("%d", &n);

    vector<pair<int, int> > v;

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

        int x;

        scanf("%d", &x);

        v.emplace_back(x, i);

    }

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

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

}

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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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



using namespace std;



int main()

{

	long long n;

	cin>>n;

	long long arr[n];

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

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

	{

		cin>>arr[i];

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

	}

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

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

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

}


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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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

using namespace std;



int main( )

{

    int n, i, j, k;

    vector< pair<int, int> > v;

    cin >> n;

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

        cin >> j;

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

    }

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

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

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

        cout << v[i].second;

    }

    cout << '\n';

    return 0;

}


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

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

}
// Slower C++ solution:
#include<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.219638023964094x):
#include<stdio.h>

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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

#include <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.238604205845042x):
#include<stdio.h>

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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

#include<algorithm>

using namespace std;





struct 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.220905485362151x):
#include<stdio.h>

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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

#include<vector>

#include<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.2137395475745745x):
#include<stdio.h>

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

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

#include<algorithm>

using namespace std;



struct 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.226196120463326x):
#include<stdio.h>

#include<algorithm>

using namespace std;

struct node {

	int a, b;

	bool operator<(const node& p)const {

		return a < p.a;

	}

}A[100005];

int main() {

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

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

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

		A[i].b = i;

	}

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

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

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

}