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

#include<vector>

#include<algorithm>

using namespace std;

const int M=1e5+5;

struct stu{

	int id;

	int val;

	stu(){

	}

	stu(int a,int b){

		id=a;

		val=b;

	}

	bool operator < (const stu &s)const{

		return val<s.val;

	}

};

int n,num;

int a[M];

vector<stu>v;

int main()

{

	cin>>n;

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

	{

		cin>>num;

		v.push_back(stu(i+1,num));

	}

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

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

	{

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

	}

	cout<<v[v.size()-1].id<<endl;

	return 0;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

        scanf("%d", &stu[i].rank);

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

    printf("%d", stu[0].num);

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

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

#include<iostream>

using namespace std;

const int N=22e4;



int a[N],r[N];

bool cmp(int x,int y){

	return a[x]<a[y];

}

int main(){

	ios::sync_with_stdio(0);

	int n;

	cin>>n;

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

		cin>>a[i];

		r[i]=i;

	}

	sort(r,r+n,cmp);

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

		cout<<r[i]+1<<' ';

	return 0;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

        scanf("%d", &stu[i].rank);

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

    printf("%d", stu[0].num);

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

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include<algorithm>

using namespace std;

pair<int,int> a[200000];

int main(){

    int n;

    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++){

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

    }

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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



using namespace std;



int main() {

	int n;

	cin >> n;

	map<int, int> m;

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

		int in;

		cin >> in;

		m[in] = i;

	}

	for (auto item : m) {

		cout << item.second << " ";

	}

	return 0;

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include<algorithm>

using namespace std;

struct node

{

	int id;

	int xu;

	bool operator <(const node o)const

	{

		return xu<o.xu;

	}

}a[100010];

int main()

{

	int n;

	cin>>n;

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

	{

		cin>>a[i].xu;

		a[i].id=i;

	}

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

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

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

	return 0; 

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include<iostream>

#include<algorithm>

using namespace std;

struct da

{

	int i,s;

}a[100010];

bool operator<(da p1,da p2)

{

	if(p1.s<p2.s)return 1;

	else return 0;

}

int main(void)

{

	int n;

	cin>>n;

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

	a[i].i=i;

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

	cin>>a[i].s;

	sort(&a[1],&a[1+n]);

	cout<<a[1].i;

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

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

	return 0;

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include <algorithm>

#include <vector>

#include <math.h>

#include <string>

using namespace std;



struct student {

    int number;

    int rank;

    

    student() {number = 1; rank = 0;}

};



int N;

vector<student> a;



bool PX (student x, student y) {

    return x.rank < y.rank;

}



int main() {

    cin>>N;

    int r;

    student t;

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

        cin>>r;

        t.number = x; t.rank = r;

        a.push_back(t);

    }

    sort(a.begin(), a.end(), PX);

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

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

    }

    return 0;

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.7962704609252236x):
#include "algorithm"

#include "iostream"

using namespace std;

int n, a[100001];

pair<int, int> x[100001];

int main() {

    while (cin >> n) {

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

            cin >> x[i].first;

            x[i].second = i;

        }

        sort(x, x + n);

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

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

        }

        cout << endl;

    }

}
// 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.800181617356326x):
#include<iostream>

#include<algorithm>

using namespace std;

struct student 

{

	int index;

	int num;

	bool operator < (const student& p) const 

	{

		return num< p.num;

	}

};

student s[100005];

int main()

{

	int n;

	cin>>n;

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

	{

		s[i].index=i+1;

		cin>>s[i].num;

	 } 

	sort(s,s+n);

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

	{

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

	}

	return 0;

 }
// 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.8037180065406768x):
#include<iostream>

#include<algorithm>

using namespace std;

struct student 

{

	int index;

	int num;

	bool operator < (const student& p) const 

	{

		return num< p.num;

	}

};

student s[100005];

int main()

{

	int n;

	cin>>n;

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

	{

		s[i].index=i+1;

		cin>>s[i].num;

	 } 

	sort(s,s+n);

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

	{

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

	}

	return 0;

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include<algorithm>

using namespace std;

int n;

struct node{

	int r,index;

	bool operator<(const node &p)const

	{

		return r<p.r;

	}

}a[100005];

int main()

{

	cin>>n;

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

	{

		cin>>a[i].r;

		a[i].index=i+1;

	}

	sort(a,a+n);

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

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

	return 0;

}
// 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.8035914144983867x):
#include<iostream>

#include<algorithm>

using namespace std;

int n;

struct node{

	int r,index;

	bool operator<(const node &p)const

	{

		return r<p.r;

	}

}a[100005];

int main()

{

	cin>>n;

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

	{

		cin>>a[i].r;

		a[i].index=i+1;

	}

	sort(a,a+n);

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

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

	return 0;

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include<algorithm>

using namespace std;

const int maxn=1e5+5;

int n,a[maxn];

struct stu{

 int idx,total;

 bool operator <(const stu& s)const{

      return total<s.total;

 }

}s[maxn];



int main()

{

 cin>>n;

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

 {

  cin>>a[i];

  s[i].idx=i;

  s[i].total=a[i];

 } 

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

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

 {

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

 }

 return 0;

}
// 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.8036604475778684x):
#include<iostream>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;

int n,a[maxn];

struct stu{

 int idx,total;

 bool operator <(const stu& s)const{

      return total<s.total;

 }

}s[maxn];



int main()

{

 cin>>n;

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

 {

  cin>>a[i];

  s[i].idx=i;

  s[i].total=a[i];

 } 

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

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

 {

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

 }

 return 0;

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include<cstring>

#include<algorithm>

#include<queue>

#include<cmath>

#include<iostream>

#include<cstring>

using namespace std;

template<class _T>inline void read(_T &_a)

{

    bool f=0; char _c=getchar(); _a=0;

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

    while(_c>='0'&&_c<='9'){ _a=(_a<<3)+(_a<<1)-'0'+_c; _c=getchar(); }

    if(f) _a=-_a;

}



const int MAXN=100002;

int n;

struct NODE

{

    int a,id;

    inline bool operator < (const NODE &x) const { return a<x.a; }

}e[MAXN];



int main()

{

    read(n);

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

    {

        read(e[i].a);

        e[i].id=i;

    }

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

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

    return 0;

}
// 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.8313405101926543x):
#include<cstdio>

#include<cstring>

#include<algorithm>

#include<queue>

#include<cmath>

#include<iostream>

#include<cstring>

using namespace std;

template<class _T>inline void read(_T &_a)

{

    bool f=0; char _c=getchar(); _a=0;

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

    while(_c>='0'&&_c<='9'){ _a=(_a<<3)+(_a<<1)-'0'+_c; _c=getchar(); }

    if(f) _a=-_a;

}



const int MAXN=100002;

int n;

struct NODE

{

    int a,id;

    inline bool operator < (const NODE &x) const { return a<x.a; }

}e[MAXN];



int main()

{

    read(n);

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

    {

        read(e[i].a);

        e[i].id=i;

    }

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

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

    return 0;

}