stablegradients/pie-gem5-pairs huggingface dataset:
// 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.2743232840200935x):
#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 <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.266841905850238x):
#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(){

	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.271296948767007x):
#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 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.340468202144728x):
#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<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.216551450273062x):
#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=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.216383647900977x):
#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<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+10;



struct at{

	int x;

	int index;

}a[maxn];

bool cmp(at b,at c){

	return b.x<c.x;

}

int main(){

	int n;

	cin>>n;

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

		cin>>a[i].x;

		a[i].index=i;

	}

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

	cout<<a[1].index;

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

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

	}

	cout<<endl;

	return 0;

} 

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

bool cmp(pair<int,int> a,pair<int,int> b)

{

	if(a.second<b.second)

	 return true;

	else

	 return false;

}

int main()

{

	int n;

	pair<int,int> p[100100];

	cin>>n;

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

	{

		int t;

		cin>>t;

		p[i].first=i;

		p[i].second=t;

	} 

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

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

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

	return 0;

	

} 

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

#include<algorithm>

#include<cstdio>

using namespace std;

int n;

struct node{

	int index;

	int Zhi;

}A[100005];

bool cmp(node A, node B){ return A.Zhi < B.Zhi; }

int main(){

	cin >> n;

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

		cin >> A[i].Zhi;

		A[i].index = i+1;

	}

	sort(A, A + n, cmp);

	for(int i = 0; i < n; i++) cout << A[i].index << " ";

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

#include<algorithm>

using namespace std;

bool cmp(pair<int,int> a,pair<int,int> b)

{

	if(a.second<b.second)

	 return true;

	else

	 return false;

}

int main()

{

	int n;

	pair<int,int> p[100100];

	cin>>n;

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

	{

		int t;

		cin>>t;

		p[i].first=i;

		p[i].second=t;

	} 

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

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

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

	return 0;

	

} 

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

#include<algorithm>

using namespace std;

int n;

struct stu

{

	int i;

	int m;

};

stu s[100010];

bool compare(stu a,stu b)

{

	return a.m<b.m;

}

int main()

{

	cin>>n;

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

	{

		int t;

		cin>>t;

		s[j].i=j;

		s[j].m=t;

	}

	sort(s,s+n,compare);

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

    	cout<<s[j].i+1<<" ";

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

#include<algorithm>

using namespace std;

bool cmp(pair<int,int> a,pair<int,int> b)

{

	if(a.second<b.second)

	 return true;

	else

	 return false;

}

int main()

{

	int n;

	pair<int,int> p[100100];

	cin>>n;

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

	{

		int t;

		cin>>t;

		p[i].first=i;

		p[i].second=t;

	} 

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

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

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

	return 0;

	

} 

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

#include<algorithm>

using namespace std;

struct node{

	int i,num;

}A[110000];

bool fun(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,fun);

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

	{

		cout<<A[i].i<<" ";

	}

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

#include<algorithm>

using namespace std;

bool cmp(pair<int,int> a,pair<int,int> b)

{

	if(a.second<b.second)

	 return true;

	else

	 return false;

}

int main()

{

	int n;

	pair<int,int> p[100100];

	cin>>n;

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

	{

		int t;

		cin>>t;

		p[i].first=i;

		p[i].second=t;

	} 

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

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

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

	return 0;

	

} 

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

#include<string>

#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{

		if(total!=s.total) 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<<" ";

	}

/*	for(int j=1;j<=n;j++)

	{

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

		{

			if(j==a[i]) cout<<i<<" ";

		}

	}*/ 

	

	return 0;

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

#include<algorithm>

using namespace std;

bool cmp(pair<int,int> a,pair<int,int> b)

{

	if(a.second<b.second)

	 return true;

	else

	 return false;

}

int main()

{

	int n;

	pair<int,int> p[100100];

	cin>>n;

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

	{

		int t;

		cin>>t;

		p[i].first=i;

		p[i].second=t;

	} 

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

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

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

	return 0;

	

} 

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

using namespace std;

int n;

struct node

{

	int pos;

	int num;

}a[100005];

bool cmp(node x, node y)

{

	return x.num < y.num;

}

int main()

{

	cin >> n;

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

	{

		cin >> a[i].num;

		a[i].pos = i;

	}

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

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

	return 0;

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

#include<algorithm>

using namespace std;

bool cmp(pair<int,int> a,pair<int,int> b)

{

	if(a.second<b.second)

	 return true;

	else

	 return false;

}

int main()

{

	int n;

	pair<int,int> p[100100];

	cin>>n;

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

	{

		int t;

		cin>>t;

		p[i].first=i;

		p[i].second=t;

	} 

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

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

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

	return 0;

	

} 

// Faster C++ solution for the same problem (measured speedup: 1.7711825703358612x):
//      https://youtu.be/X_hMZYDMps4



#include<bits/stdc++.h>

using namespace std;



typedef long long ll;

typedef long double ld;

typedef long long unsigned llu;

typedef pair<long long, long long> pll;

const long long inf = 2000000000000000000LL;    // 2e18

#define pi                  acos(-1.0)

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

#define nl                  "\n"

#define ff                  first

#define ss                  second

#define pb                  push_back

#define pf                  push_front

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

#define debug(x)            cout<<"debug "<<x<<"\n"



int main()

{

    fast;

    ll t,i,j,k,l,m,n,o,p,q,temp,ans=0,flag=0,mod=1000000007,odd=0,even=0;

    cin>>n;

    vector<pll>v(n);

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

        cin>>v[i].ff;

        v[i].ss=i+1;

    }

    sort(all(v));

    for(i=0;i<n;i++) cout<<v[i].ss<<" ";

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

#include<algorithm>

using namespace std;

bool cmp(pair<int,int> a,pair<int,int> b)

{

	if(a.second<b.second)

	 return true;

	else

	 return false;

}

int main()

{

	int n;

	pair<int,int> p[100100];

	cin>>n;

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

	{

		int t;

		cin>>t;

		p[i].first=i;

		p[i].second=t;

	} 

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

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

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

	return 0;

	

} 

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

using namespace std;



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

#define endl            "\n"

#define sq(x)           ((x)*(x))

#define pi              acos(-1.0)

#define NUM             1000005



typedef long long ll;





int main()

{

    FastRead



    ll n,x=0,y=0,ans=0;



    cin>>n;



    map<ll,ll>mp;



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

    {

        ll temp;

        cin>>temp;



        mp[temp] = i;

    }



    for(auto it:mp)

        cout<<it.second<<" ";

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

#include<iostream>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace  std;

struct node

{

	int a,b;

}edge[101010];

bool cmp(node x,node y)

{

	return x.a < y.a;

}

int n;

int main()

{

	cin>>n;

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

	{

		cin>>edge[i].a;

		edge[i].b=i;

	}

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

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

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

	

	return 0;

}








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

#include <algorithm>

using namespace std;

struct ss{

	int n;

	int i;

}s[100005];

bool cmp (ss x, ss y)

{

	return x.n < y.n;

}

int main(void)

{

	int n;

	scanf("%d", &n);

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

	{

		scanf("%d", &s[i].n);

		s[i].i = i;

	}

	sort(s, s + n, cmp);

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

	{

		printf("%d", s[i].i + 1);

		if(i != n - 1)

			printf(" ");

	}

	printf("\n");

	return 0;

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

#include<iostream>

#include<cstring>

#include<cmath>

#include<algorithm>

using namespace  std;

struct node

{

	int a,b;

}edge[101010];

bool cmp(node x,node y)

{

	return x.a < y.a;

}

int n;

int main()

{

	cin>>n;

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

	{

		cin>>edge[i].a;

		edge[i].b=i;

	}

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

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

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

	

	return 0;

}








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

#include<algorithm>

using namespace std;

#define range 100000+10

int N=0;

struct stu{

	int id;

	int rank;

};

bool com(const stu&a,const stu&b){

	return a.rank<b.rank;

}

stu a[range];

int main(){

	scanf("%d",&N);

	int tmp;

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

		scanf("%d",&tmp); 

		a[i].id=i;

		a[i].rank=tmp;

	}

	sort(a,a+N,com);

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

		printf("%d ",a[i].id+1);

	}

	printf("%d",a[N-1].id+1);

	return 0;

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

using namespace std;

struct siswa{

	int idx;

	int num;

};

bool cmp(siswa a,siswa b){

	return a.num<b.num;

}

int main(){

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

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

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

	}

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

	cout<<v[0].idx;

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

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

	}

	cout<<endl;

}

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

#include<algorithm>

using namespace std;

#define range 100000+10

int N=0;

struct stu{

	int id;

	int rank;

};

bool com(const stu&a,const stu&b){

	return a.rank<b.rank;

}

stu a[range];

int main(){

	scanf("%d",&N);

	int tmp;

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

		scanf("%d",&tmp); 

		a[i].id=i;

		a[i].rank=tmp;

	}

	sort(a,a+N,com);

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

		printf("%d ",a[i].id+1);

	}

	printf("%d",a[N-1].id+1);

	return 0;

}
// Slower C++ solution:
/*

the top of the losers

*/

#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

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

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

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

#define   pb         push_back

#define   mp         make_pair

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

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

#define    x            real()

#define    y            imag()

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

#define     point        complex<double>

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

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

typedef  long long     ll ;

typedef  unsigned long long     ull ;

const double eps= (1e-9);

using namespace std;

using namespace __gnu_pbds;

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

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

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

vector< pair<int,int> > v;

int main(){

    GO();

    int n;

    cin>>n;

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

        int no;

        cin>>no;

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

    }

    sort(all(v));

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

        if(i==0)

        cout<<v[i].second;

        else

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

    }

    cout<<endl;

}


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

#include<algorithm>

using namespace std;

#define range 100000+10

int N=0;

struct stu{

	int id;

	int rank;

};

bool com(const stu&a,const stu&b){

	return a.rank<b.rank;

}

stu a[range];

int main(){

	scanf("%d",&N);

	int tmp;

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

		scanf("%d",&tmp); 

		a[i].id=i;

		a[i].rank=tmp;

	}

	sort(a,a+N,com);

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

		printf("%d ",a[i].id+1);

	}

	printf("%d",a[N-1].id+1);

	return 0;

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

#include<iostream>

#include<algorithm>

using namespace std;

int n;

struct lxs

{

	int t,x;

}st[100010];

bool cmp(lxs a,lxs b)

{

	return a.t<b.t;

}

int main()

{

	scanf("%d",&n);

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

	{

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

		st[i].x=i;

	}

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

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

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

	return 0;

}

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

#include<algorithm>

using namespace std;

#define range 100000+10

int N=0;

struct stu{

	int id;

	int rank;

};

bool com(const stu&a,const stu&b){

	return a.rank<b.rank;

}

stu a[range];

int main(){

	scanf("%d",&N);

	int tmp;

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

		scanf("%d",&tmp); 

		a[i].id=i;

		a[i].rank=tmp;

	}

	sort(a,a+N,com);

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

		printf("%d ",a[i].id+1);

	}

	printf("%d",a[N-1].id+1);

	return 0;

}
// Slower C++ solution:


#include<bits/stdc++.h> 

using namespace std; 



int main() 

{ 

    

    vector< pair <int,int> > vect; 

    int n,t;

    cin>>n; 

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

    {

        cin>>t;

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

    }

    



    

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



   

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

    { 

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

    } 



    return 0; 

} 




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

#include<algorithm>

using namespace std;

#define range 100000+10

int N=0;

struct stu{

	int id;

	int rank;

};

bool com(const stu&a,const stu&b){

	return a.rank<b.rank;

}

stu a[range];

int main(){

	scanf("%d",&N);

	int tmp;

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

		scanf("%d",&tmp); 

		a[i].id=i;

		a[i].rank=tmp;

	}

	sort(a,a+N,com);

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

		printf("%d ",a[i].id+1);

	}

	printf("%d",a[N-1].id+1);

	return 0;

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



using namespace std;



int main() {

  int n; cin >> n;

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

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

    cin >> a[i];

    ord[i] = i;

  }

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

    return a[x] < a[y];

  };

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

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

}

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

#include<algorithm>

using namespace std;

#define range 100000+10

int N=0;

struct stu{

	int id;

	int rank;

};

bool com(const stu&a,const stu&b){

	return a.rank<b.rank;

}

stu a[range];

int main(){

	scanf("%d",&N);

	int tmp;

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

		scanf("%d",&tmp); 

		a[i].id=i;

		a[i].rank=tmp;

	}

	sort(a,a+N,com);

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

		printf("%d ",a[i].id+1);

	}

	printf("%d",a[N-1].id+1);

	return 0;

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

using namespace std;



typedef long long ll;

int ara[60];

int main()

{

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

    vector< pair <int, int> > pii;

    int n;

    cin>>n;

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

    {

        int a;

        cin>>a;

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

    }

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

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

    {

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

    }

    cout<<endl;

    return 0;

}

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

#include<algorithm>

using namespace std;

#define range 100000+10

int N=0;

struct stu{

	int id;

	int rank;

};

bool com(const stu&a,const stu&b){

	return a.rank<b.rank;

}

stu a[range];

int main(){

	scanf("%d",&N);

	int tmp;

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

		scanf("%d",&tmp); 

		a[i].id=i;

		a[i].rank=tmp;

	}

	sort(a,a+N,com);

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

		printf("%d ",a[i].id+1);

	}

	printf("%d",a[N-1].id+1);

	return 0;

}