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

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cmath>

#include <vector>

#include <string>

using namespace std;

typedef long long ll;

const int maxn=2e5+10;

ll n,m,k,d,q;



pair<int,int> b[maxn];

int a[maxn];



int main()

{

    int n,k;

    cin>>n;

    int ans=0;

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

    {

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

        b[i]=make_pair(a[i],i+1);

    }

    sort(b,b+n);

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

         printf(i!=n-1?"%d ":"%d",b[i].second);

    }

    return 0;

}


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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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



using namespace std;



int main() {

    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);



    int n;

    cin >> n;



    vector<array<int , 2> > v(n);

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

        int x;

        cin >> x;

        v[i - 1] = {x , i};

    }



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



    for (auto &c : v)

        cout << c[1] << ' ';

}

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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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



using namespace std;

const int N=3e5+5;

int a[N];

int main()

{

    ios_base::sync_with_stdio(0);

    cin.tie(0);cout.tie(0);

    int n;

    cin>>n;

    vector<pair<int,int> >v;

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

    {

        int x;

        cin>>x;

        v.push_back({x,i});

    }

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

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

    {

        if(i) cout<<" ";

        cout<<v[i].second;

    }

    cout<<endl;

    return 0;

}


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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

 

using namespace std;

 

typedef int in;

#define int long long

 

in main() {

    int n;

    cin >> n;

    vector<pair<int,int> > v;

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

        int a;

        cin >> a;

        v.push_back({a,i + 1});

    }

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

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

        if(i){

            cout << " ";

        }

        cout << v[i].second;

    }

    cout << endl;

    return 0;

}

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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

#include<cstdio>

#define ll long long int

#define pb push_back

using namespace std;

int main()

{

    ll a,b,n,i,j,k;

    vector<ll>v[60];

    map<ll,ll>m;

    set<ll>s;

    cin>>n;

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

    {

        cin>>k;

        m[k]=i;

        s.insert(k);

    }

    for(auto x:s)

    {

        cout<<m[x]<<" ";

    }

    cout<<endl;



    return 0;

}


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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

using namespace std;

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

#define  ll  long long

#define  pi  pair<int,int>

#define  pb  push_back

#define  F   first

#define  S   second

const int N=2e5+2;

pi a[N];

int main()

{

    ft

    int t,i,j,n,m,l=0,r,z=0;

    cin>>n;

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

    {

        cin>>l;

        a[i]={l,i};

    }

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

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

    {

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

    }

    return 0;

}




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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

#define ll long long int

#define sz  200010

using namespace std;





priority_queue<pair<ll,ll> >q;







int main()

{



   ll n,i,j,a,b,x,y;



   cin>>n;



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

   {

       cin>>a;

       q.push({-a,i});

   }

   ll c=0;





   while(!q.empty())

   {

       a=q.top().second;

       q.pop();

       c++;

       cout<<a;

       if(c!=n)cout<<" ";



   }

   cout<<endl;





  return 0;

}




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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

using namespace std;

int main()

{

    int n,i,j,x;

    cin>>n;

    vector<pair<int,int> >vi;

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

    {

        cin>>x;

        vi.push_back(make_pair(x,i));

    }

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

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

    {

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

    }

    cout<<endl;

}


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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

#include <map>



using namespace std;



int main(int argc, char const *argv[])

{

    int n, stu;

    cin >> n;

    map<int, int> pos;

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

    {

        cin >> stu;

        pos[stu] = i;

    }

    for (auto m : pos)

    {

        cout << m.second << " ";

    }

    return 0;

}


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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

using namespace std;



int main(){

	int n;

	cin >> n;

	vector<pair<int, int> > v;

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

		int x;

		cin >> x;

		v.push_back(make_pair(x, i+1));

	}

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

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

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

	}

	cout << v[v.size()-1].second << "\n";

}

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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

using namespace std;

#define found(m,x) ((m).find(x)!=(m).end())

#define uset unordered_set

#define umap unordered_map

#define db(x) cerr << #x << " == " << x << ";\n";

#define a(x) x.begin(),x.end()

#define input(v,n) for(int i=0;i<n;i++)cin>>v[i]

typedef vector<int> vi;

typedef pair<int,int> pi;



const int nax = 1e5+7;

const int mod = 1e9+7; //1e9+2667

const int inf = numeric_limits<int> :: max();

// ===================== MANASH =================== //



int n,m;



void test() {



	cin >> n;

	vector<pair<int,int>> arr;

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

		int a;

		cin >> a;

		arr.push_back({a,i+1});

	}

	sort(a(arr));



	for( auto p : arr ) {

		cout << p.second << ' ';

	}

}





signed main() {



	ios_base :: sync_with_stdio(false);

	cin.tie(NULL);



	#ifdef LOCAL

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

	cout<<"Time Elapsed: " << 1.0*clock() / CLOCKS_PER_SEC << " sec.\n";

	#endif



	int T = 1;

	//cin >> T;

	while(T--) {

		test();

		cout << "\n";

	}

	return 0;



}

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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

#include<string>

#include<algorithm>

#include<math.h>

#include<stdio.h>

#define MAXN 100010

using namespace std;

int n;

struct stu

{

    int num;

    int idx;

    bool operator < (const stu & x) const{

        return num<x.num;

    }

}a[MAXN];

int main()

{

    cin>>n;

    int x;

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

    {

        cin>>x;

        a[i].idx=i;

        a[i].num=x;

    }

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

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

    cout<<endl;

    return 0;

}

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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

using namespace std;

const int maxn=1e5+10;

int N;

struct S{

	int index;

	int num;

	bool operator <(const S& x)const{

		return num<x.num;

	}

}A[maxn];



int main()

{

	cin>>N;

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

		cin>>A[i].num;

		A[i].index=i+1;

	}

	sort(A,A+N);

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

        cout<<A[i].index<<' ';

    cout<<endl;

	

	

	return 0;

}

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

#include<algorithm>

using namespace std;



struct STU{

	int idx,ai;

	

	bool operator < (const STU& s) const {

		return ai<s.ai;

	}

	

}stu[100005];



int N;



int main(){

	

	scanf("%d",&N);

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

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

		stu[i].idx=i+1;

	}

	sort(stu,stu+N);

	

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

		printf("%d ",stu[i].idx);

	printf("%d\n",stu[N-1].idx);

	return 0;

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

#include <algorithm>

using namespace std;

struct Node{

	int number, a;

} node[100005];



int cmp(Node a, 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].number = i; 

	}

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

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

	{

		if (i != n)

		{

			cout << node[i].number << " ";

		}

		else

		{

			cout << node[i].number << endl;

		}

	}

	return 0;

}

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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

#include <algorithm>

using namespace std;

int n,a[123456],b[123455];

bool PP(int i,int j){

    return a[i]<a[j];

}

int main(){

    cin>>n;

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

        cin>>a[i];

        b[i]=i;

    }

    sort(b+1,b+1+n,PP);

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

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

    return 0;

}

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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

#include <algorithm>

#include <stdio.h>

#include <vector>

#include <iomanip>

#include <stdlib.h>



using namespace std;



#define LL long long

#define FOR(i,l,r) for(int i = l; i <= r; ++i)

#define REP(i,l,r) for(int i = l; i < r; ++i)

#define pi pair<int,int>

#define mp make_pair



const int maxN = 1e5 + 11;

const LL oo = 1e17 + 11;



int N,K;

int A[maxN],C[maxN];

bool cmp(int i,int j){

    return A[i] < A[j];

}



int main(){

    ios_base::sync_with_stdio(false);

    cin.tie();

    cout.tie();

    //



    cin >> N;

    FOR(i,1,N){

        cin >> A[i];

        C[i] = i;

    }

    sort(C + 1,C + 1 + N,cmp);

    //

    FOR(i,1,N) cout << C[i] << " ";



    return 0;

}

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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

using namespace std;

const int maxn=100000+50;



struct node{

	int id,rank;

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

	bool operator <(const node& rhs) const {

		return rank<rhs.rank;

	}

}a[maxn];





int n,x,y;



int main(){

	scanf("%d",&n);

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

		scanf("%d",&x);

		a[i-1].id=i;a[i-1].rank=x;

	}

	sort(a,a+n);

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

}

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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

#include <iostream>

#include <cstring>

#include <algorithm>

#include <cmath>

#include <vector>

#include <string>

using namespace std;

typedef long long ll;

const int maxn=2e5+10;

ll n,m,k,d,q;



pair<int,int> b[maxn];

int a[maxn];



int main()

{

    int n,k;

    cin>>n;

    int ans=0;

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

    {

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

        b[i]=make_pair(a[i],i+1);

    }

    sort(b,b+n);

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

         printf(i!=n-1?"%d ":"%d",b[i].second);

    }

    return 0;

}


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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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



using namespace std;



int main() {

    ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);



    int n;

    cin >> n;



    vector<array<int , 2> > v(n);

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

        int x;

        cin >> x;

        v[i - 1] = {x , i};

    }



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



    for (auto &c : v)

        cout << c[1] << ' ';

}

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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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



using namespace std;

const int N=3e5+5;

int a[N];

int main()

{

    ios_base::sync_with_stdio(0);

    cin.tie(0);cout.tie(0);

    int n;

    cin>>n;

    vector<pair<int,int> >v;

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

    {

        int x;

        cin>>x;

        v.push_back({x,i});

    }

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

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

    {

        if(i) cout<<" ";

        cout<<v[i].second;

    }

    cout<<endl;

    return 0;

}


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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

 

using namespace std;

 

typedef int in;

#define int long long

 

in main() {

    int n;

    cin >> n;

    vector<pair<int,int> > v;

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

        int a;

        cin >> a;

        v.push_back({a,i + 1});

    }

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

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

        if(i){

            cout << " ";

        }

        cout << v[i].second;

    }

    cout << endl;

    return 0;

}

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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

#include<cstdio>

#define ll long long int

#define pb push_back

using namespace std;

int main()

{

    ll a,b,n,i,j,k;

    vector<ll>v[60];

    map<ll,ll>m;

    set<ll>s;

    cin>>n;

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

    {

        cin>>k;

        m[k]=i;

        s.insert(k);

    }

    for(auto x:s)

    {

        cout<<m[x]<<" ";

    }

    cout<<endl;



    return 0;

}


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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

using namespace std;

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

#define  ll  long long

#define  pi  pair<int,int>

#define  pb  push_back

#define  F   first

#define  S   second

const int N=2e5+2;

pi a[N];

int main()

{

    ft

    int t,i,j,n,m,l=0,r,z=0;

    cin>>n;

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

    {

        cin>>l;

        a[i]={l,i};

    }

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

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

    {

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

    }

    return 0;

}




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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

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

#define ll long long int

#define sz  200010

using namespace std;





priority_queue<pair<ll,ll> >q;







int main()

{



   ll n,i,j,a,b,x,y;



   cin>>n;



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

   {

       cin>>a;

       q.push({-a,i});

   }

   ll c=0;





   while(!q.empty())

   {

       a=q.top().second;

       q.pop();

       c++;

       cout<<a;

       if(c!=n)cout<<" ";



   }

   cout<<endl;





  return 0;

}




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

#include <cstdio>

using namespace std;

const int maxn=1e5+5;

pair<int,int> a[maxn];



int main()

{

    int n;

    scanf("%d",&n);

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

    {

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

        a[i].second=i;

    }

        

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

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

    {

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

    }









    return 0;

}