stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cmath>

#include <cstring>

#include <string>

#include <climits>

#include <algorithm>

#include <queue>

#include <vector>

#define ll long long

using namespace std;

struct re

{

    int a;

    int id;

}p[100005];

bool cmp(re x,re y)

{

    return x.a < y.a;

}

int main()

{

    int n;

    cin>>n;

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

    {

        int x;

        cin>>x;

        p[i].id =  i;

        p[i].a = x;

    }

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

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

    {

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

    }

    return 0;

}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <cstdio>

#include <algorithm>

#include <iostream>

#include <bitset>

#include <set>

#include <sstream>

#include <string>

#include <cstring>

#include <stack>

#include <cmath>

#include <queue>

#include <cctype>

#include <map>

#include <cstdlib>

#include <vector>

#define ll long long

#define INF 0x3f3f3f3f

using namespace std;



ll read(){

    ll x=0,f=1;char ch=getchar();

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

    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}

    return x*f;

}



int n;

struct info{

    int id,num;

}a[100005];

bool cmp(info x,info y){

    return x.num<y.num;

};





int main() {

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

    n = read();

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

        a[i].num=read();

        a[i].id=i;

    }

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

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

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



}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<algorithm>

using namespace std;

int n;

pair<int, int> a[100005];

int main ()

{

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

	{

		if(i!=1)	cout<<" ";

		cout<<a[i].second;

	}

	cout<<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm> 

using namespace std;



struct node

{

	int index;

	int ai;

};



bool cmp(node a,node b)

{

	return a.ai<b.ai;

}



int main()

{

	int n;

	cin>>n;

	node stu[n+1];

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

	{

		cin>>stu[i].ai;

		stu[i].index=i;

	}

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

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

	{

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

	}

	cout<<endl;

	

} 

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <algorithm>

using namespace std;



int n;

struct per

{

	int idx;

	int cnt;

	

	bool operator < (const per& t) const

	{

		return cnt<t.cnt;

	}

}p[500010];



int main()

{

	cin>>n;

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

	{

		cin>>p[i].cnt;

		p[i].idx=i;

	}

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

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

	{

		if(i!=n)

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

		else

			cout<<p[i].idx<<"\n";	

	}	

	

	return 0;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

int n;

map<int,int>per;

int main()

{

	scanf("%d",&n);

	int rnk=0;

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

		scanf("%d",&rnk);

		per[rnk]=i+1;

	}

	int cnt=0;

	for(map<int,int>::iterator i=per.begin();i!=per.end();i++){

		if(cnt++) printf(" ");

		printf("%d",i->second);

	}

	return 0;

} 

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<algorithm>

using namespace std;

struct stu

{

	int idx;

	int tol;

	bool operator<(const stu s) const

	{

		return tol<s.tol;

	}

};

const int sz=1e5+10;

stu stud[sz]; 

int main(void)

{

	int N;

	cin>>N;

	for(int i=1;i<=N;i++)		//从1开始 

	{

		stud[i].idx=i;

		cin>>stud[i].tol;

	} 

	sort(stud+1,stud+N+1);		//排完序

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

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

	cout<<endl; 

	return 0;

} 

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
//

//  main.cpp

//  lab1

//

//  Created by 王黎杉 on 2020/5/29.

//  Copyright © 2020 王黎杉. All rights reserved.

//



#include <algorithm>

#include <vector>

#include <iostream>

using namespace std;



vector<pair<int,int>> classroom;



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

{

    return a.second < b.second;

}



int main()

{

    ios::sync_with_stdio(false);

    

    int n = 0,a = 0;

    

    cin>>n;

    

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

    {

        cin>>a;

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

    }

    

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

    

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

    {

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

    }

    

    

    return 0;

}


// Optimized solution to the same problem (faster):
#include<cstdio>

#include<algorithm>

using namespace std;

const int maxn=1e5+5;



struct stu{

	int num,flag;

	bool operator<(stu &s){

		return num<s.num;

	}

}st[maxn];



int main(){

	int n;

	scanf("%d",&n);

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

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

	    st[i].flag=i+1; 

	} 

	sort(st,st+n);

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

	return 0;	

} 

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



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

#define ll long long

#define endl '\n'



int main()

{

	int n,a[100005];

	map<int,int>m;

	cin >>n;

	

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

	{

		cin >> a[i];

		m.insert({a[i],i});

	}

	vector<int>v;

	for(auto it : m)

	{

		v.push_back(it.second);

	} 

	

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

	{

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

	}

	cout << v[n-1] << endl;

	return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <algorithm>

using namespace std;

const int maxn = 1e5 + 5;

struct Node {

    int id, num;

}node[maxn];

bool cmp(Node &a, Node &b) {

    return a.num < b.num;

}

int main() {

    int n;

    scanf("%d", &n);

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

        scanf("%d", &node[i].num), node[i].id = i + 1;

    sort(node, node + n, cmp);

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

        printf("%d ", node[i].id);

    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<algorithm>

#include<cstring>

#include<iomanip>

#include<cmath>

#include<cstdio>

#define ll long long

using namespace std;

const int N=100010;



struct node{

    int a;

    int b;

};

bool cmp(struct node m, struct node n)

{

    return m.a<n.a;

}

int main() {

    std::ios::sync_with_stdio(false);

    std::cin.tie(NULL);

    std::cout.tie(NULL);

    int n,m;

    node node[N];

    int ans=0;

    cin>>n;

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

        cin>>m;

        node[i].a=m;

        node[i].b=i+1;

    }

    sort(node,node+n,cmp);

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

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

 }

 cout<<endl;

 return 0;

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
/*|In The Name Of Allah|*/



#include <bits/stdc++.h>



using namespace std;



const int N = 1e5+5;



int n;

int a[N];

vector < int > idx;



bool cmp(int x , int y){

    if(a[x] < a[y])

        return 1;

    return 0;

}



int main(){

    cin >> n;

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

        cin >> a[i];

        idx.push_back(i);

    }

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

    for(auto v : idx){

        cout << v << " ";

    }



}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;

const int N = 2e5+5;

pair<int,int> v[N];

int main()

{

    int n;

    cin >> n;

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

    {

        cin >> v[i].first;

        v[i].second = i;

    }

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

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

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

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#pragma GCC optimize ("O3")

#pragma GCC optimize ("unroll-loops")

#pragma GCC optimize("-Ofast")

#include <bits/stdc++.h>

using namespace std;



typedef int in;

#define int long long

#define f first

#define s second

#define pb push_back

#define pp push

#define RETURN exit(0)

#define pow(x,y) (int)(pow(x,y))

#define ceil(x) (int)(ceil(x))

#ifndef ONLINE_JUDGE

#define debug(x) cout<<x<<endl;

#else

#define debug(x) 42

#endif

const int MAX=1e4;

const int MOD=1e9+7;

const int MAAX=1e18;

const long double EPS=1e-6;

const int N=1e5+10;

int power(int x,int y)

{

    if (y == 0)

        return 1;

    int a=power(x,y/2);

    if (y % 2 == 0)

        return a * a % MOD;

    else

        return x * a * a % MOD;

}

bool check(int x){



}

int binary(int x,int y){

    int s=x,e=y,mid;

    while(s<e){

        mid=ceil((s+e)/2.0);

        if(check(mid))

            s=mid;

        else

            e=mid-1;

    }

    return s;

}

vector<int> primes;

bool visted[N+5];

void sieve(){

    visted[0]=visted[1]=1;

    for(int i=2;i*i<=N;i++){

        if(visted[i]==0){

            primes.pb(i);

            for(int j=i*i;j<=N;j+=i){

                visted[i]=1;

            }

        }

    }

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

        if(visted[i]==0)

            primes.pb(i);

    }

    return;

}



pair<int,int> arr[100010];



in main()

{

    //freopen("in.in","r",stdin);

    //freopen("out.out","w",stdout);

    int tc=1;

    //scanf("%lld",&tc);

    //sieve();

    while(tc--)

    {

        int n;

        cin>>n;

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

            cin>>arr[i].f;

            arr[i].s=i+1;

        }

        sort(arr,arr+n);

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

            cout<<arr[i].s<<" \n"[i==n-1];

        }

    }

    ///matensa4 tegarab el sample w te7ot el freopen w te3mel SCANF

    RETURN;

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>



using namespace std;



int main()

{

    int n  , x;

    cin >> n;

    int arr[n];

    vector< pair<int,int> >vp;

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

    {

        cin >> x;

        vp.push_back({x,i+1});

    }

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

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

    {

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

    }

    cout << "\n";

    return 0;

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include<bits/stdc++.h>

using namespace std;

vector<pair<int,int>>vc;

int main()

{









    int n;

    cin>>n;

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

        int x;

        cin>>x;

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

    }





sort(vc.begin(),vc.end(),[](const pair<int,int> &left, const pair<int,int> &right) {

           return left.second < right.second;







});

    for(auto x: vc)cout<<x.first<<" ";













    return 0;

}

// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <bits/stdc++.h>

using namespace std;



#define pb push_back

#define F first

#define S second

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



using ll = long long;

using ld = long double;

using ul = unsigned long long;

using ii = pair<int, int>;

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

#define ReadFile            freopen("input.in","r",stdin)

#define WriteFile           freopen("output.txt","w",stdout)

const ll mod7 = 1000000007,mod = 1000000000,OO = 0x3f3f3f3f;

const ld EPS = 1e-7;

double Pi=acos(-1);

const ld rad=Pi/180.0;

ll power(ll x, ll y, ll p)

{

    ll res = 1;

    while (y > 0)

    {

        if (y & 1)

            res = (res*x) % p;

        y = y>>1;

        x = (x*x) % p;

    }

    return res;

}

ll nCr (ll n,ll m)

{

        return(m == 0)?1:n*nCr(n-1,m-1)/m;

}

/*****************************************************/



int main()

{

    int n;

    vector<pair<int , int>> vec;

    cin >> n;



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

        int x;

        cin >> x;

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

    }



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



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

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



    return 0;

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

main(){

int i,j,k,l,n,m;

while(cin>>n){

vector<pair<int,int>> vec;

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

    cin>>j;

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

}

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

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



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

}

cout<<endl;

} return 0;

}


// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <bits/stdc++.h>

using namespace std;

#define ll long long

#define LLMAX (1ll << 60) - 1

#define INTMAX (1 << 30) - 1

#define MOD 1000000007 

#define NMAX 1000*100+1



#define numberOfSetBits(S) __builtin_popcount(S) // __builtin_popcountl(S) __builtin_popcountll(S)

#define MSET(x,y) memset(x,y,sizeof(x))

#define gcd(a,b) __gcd(a,b)

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

#define isOn(S, j) (S & (1 << j))

#define endl '\n'

#define setBit(S, j) (S |= (1 << j))

#define clearBit(S, j) (S &= ~(1 << j))

#define toggleBit(S, j) (S ^= (1 << j))

#define print(x)    for(auto it:x) cout<<it<<' '; cout<<endl;

#define printii(x)  for(auto it:x) cout<<it.F<<' '<<it.S<<'\t';  cout<<endl;

#define in(x,n)   for(int e=0;e<n;e++){ll y;cin>>y;x.pb(y);}



#define vi vector<ll>

#define vvi vector<vi>

#define ii pair<ll,ll>

#define pll pair<ll,ll>

#define vii vector<ii>

#define vvii vector<vii>

#define viii vector<pair<ii,ll>>

#define pb push_back

#define F first

#define S second

#define mp make_pair

#define mc(a,b,c) mp(mp(a,b),c)

vii a;



int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    ll n,x,t,m,y,z;

    cin>>n;

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

        cin>>x;

        a.pb(mp(x,i));

    }

    sort(all(a));

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

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

    }

    

    



    return 0;

}

// Optimized solution to the same problem (faster):
#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);

}

// Fastest known solution for this problem: