stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#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;

} 

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

}


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

	

} 

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

} 

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

}








// 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;

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;

}

// 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):
/*

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;

}


// 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<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;

}

// 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 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; 

} 




// 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 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 << ' ';

}

// 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;



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;

}

// 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):
/*ANKON GHOSH

  KUET,ECE 2K16*/

#include<bits/stdc++.h>

using namespace std;

#define ll long long

#define inf 1e18

#define MAX 4003

#define mod 1000000007

#define sf(a) scanf("%lld",&a)

#define sff(a,b) scanf("%lld %lld",&a,&b)

#define sfff(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)

#define Case(i) cout<<"Case #"<<i<<": "

#define pf(a) printf("%lld\n",a)

#define pfsn printf("NO\n")

#define pfs  printf("YES\n")

#define pff(a,b) printf("%lld %lld\n",a,b)

#define pfff(a,b,c) printf("%lld %lld %lld\n",a,b,c)

#define pffff(a,b,c,d) printf("%lld %lld %lld %lld\n",a,b,c,d)

#define FOR(i,n) for(ll i=0;i<n;i++)

#define FOR1(i,n) for(ll i=1;i<=n;i++)

#define LOOP(x,y) for(ll r=x;r<=y;r++)

#define RFOR(i,n) for(ll i=n-1;i>=0;i--)

#define RFOR1(i,n) for(ll i=n;i>0;i--)

#define RLOOP(x,y) for(ll i=y;i>=x;i--)

#define m_p(a,b) make_pair(a,b)

#define p_b(a) push_back(a)

#define ff first

#define ss second

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

map<ll,ll>mp1,mp;

vector<pair<ll,pair<ll,ll> > >vpp,vpp1;

vector<pair<ll,ll> >vp,fin;

vector<ll>v,v1,v2,dummy;

map<pair<ll,ll>,bool>mbb;

map<ll,bool>mb;

ll n,k,a,b,c,d,ta,sum=0,cnt=0,m,l,req,sz,maxi;

bool sortbysec(const pair<pair<ll,ll>,ll> &a,const pair<pair<ll,ll>,ll> &b)

{

    return (a.second < b.second);

}

vector<ll>power;

int main()

{

    string s;

    cin>>n;

    FOR(i,n)

    {

        cin>>a;

        vp.p_b(m_p(a,i+1));

    }

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

    FOR(i,n) cout<<vp[i].ss<<" ";

}

/*

5

4

3

2

3

4

4

3

3

4

2

3

*/


// 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>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;

using namespace std;

#define mp make_pair

#define pb(x) push_back(x)

#define vi vector<int>

#define vs vector<string>

#define vll vector<long long>

#define vc vector<char>

#define vs vector<string>

#define pii pair<int, int>

#define pll pair<long long, long long>

#define pil pair<int, long long>

#define pli pair<long long, int>

#define pcc pair<char, char>

#define pdd pair<double, double>

#define mll map<long long, long long>

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

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

#define flsh fflush(stdout)

#define gcd __gcd

#define clr(x) memset(x, 0, sizeof(x))

#define mod 1000000007LL

#define mod2 998244353LL

#define INF 1000000000007

 



typedef long long ll;

typedef long double ld;

typedef unsigned long long ull;

typedef tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update> o_tree;





void solve()

{

   ll n;

   cin>>n;

   pll p[n];

   ll i,j;

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

   {

       cin>>p[i].first;

       p[i].second=i+1;

   }

   sort(p,p+n);

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

   {

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

   }

   cout<<"\n";



}





int main()

{

ios_base::sync_with_stdio(false);

cin.tie(NULL);





if (fopen("input.txt","r" ))

  {

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

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

  }

cout<<setprecision(20);





ll t=1;





// cin>>t;





while(t--)

{

solve();

} 





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;

int n,m;

struct node{

	int v,n;

}a[100005];

int cmp(node a,node b)

{

	return (a.n<b.n);

}

int main()

{

	cin >> n;

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

	{

		cin >>m;

		a[i].v=i;

		a[i].n=m;

	}

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

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

	{

		if(i==1)

		cout << a[i].v;

		else

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

	}

	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 <algorithm>

#include <cmath>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <fstream>

#include <functional>

#include <iostream>

#include <map>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <string>

#include <vector>

#define LL long long

using namespace std;

inline int get_num() {

    char c;

    int f = 1, num = 0;

    while ((c = getchar()) == ' ' || c == '\n' || c == '\r')

        ;

    if (c == '-')

        f = -1;

    else

        num = c - '0';

    while (isdigit(c = getchar())) num = num * 10 + c - '0';

    return num * f;

}

const int MAXN = 1e5 + 7;

struct re {

    int a, b;

    bool operator<(const re &a) const { return b < a.b; }

} v[MAXN];

int main() {

    int n;

    cin >> n;

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

        v[i].a = i;

    }

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

        cin >> v[i].b;

    }

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

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

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

    }

    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 as

{

	int number;

	int muq;

};

bool cmp(as& a,as& b)

{

	return a.muq<b.muq;

}

as a[100010];

int main()

{

	int n;cin>>n;

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

	{

		cin>>a[i].muq;

		a[i].number=i;

		//1 2

		//2 3

		//3 1

	}

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

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

	{

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

	}

	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<stdio.h>

#include<stdlib.h>

#include <algorithm>

using namespace std;

const int maxn=1e5+10;

int N,A;

struct node

{

	int index,value;

}a[maxn];

bool cmp(node &a,node &b)

{

	return a.value<b.value ;

}

int main()

{

	cin>>N;

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

	{

		cin>>A;

		a[i].index=i;

		a[i].value=A;

	}

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

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

	{

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

	}

	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 <cstdio>

#include <algorithm>

#define N 100010

using namespace std;

struct node{

	int id,num;

}a[N];

bool cmp(const node&a1,const node&a2){

	return a1.num<a2.num;

}

int main(){

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

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

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

		a[i].id=i;

	}

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

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

		printf("%d ",a[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<iostream>

#include<algorithm>

#include<string>



using namespace std;

struct node{

	int i;

	int sum;

};



node A[100010];

bool cmp(node a,node b){

	return a.sum<b.sum;

}



int main(){

	int n;cin>>n;

    for(int i=1;i<=n;i++)cin>>A[i].sum,A[i].i=i;

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

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

	

	

	

	

	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<stdio.h>

#include<algorithm>

using namespace std;

const int maxn=100010;  //100010

int n;

struct s{

	int i,ai;

	s(){

		this->ai=this->i=0;

	} 

}a[maxn];

bool cmp(const s &a,const s &b)

{

	//if(a.b==b.b) return a.a<b.a;

	return a.ai<b.ai; 

}

int main()

{

	scanf("%d",&n);

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

	{

			scanf("%d",&a[j].ai);

			a[j].i=j;

	}

	 sort(a,a+n,cmp);

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

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

	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;

const int mx = 1E5 + 10;

struct node

{

    int id;

    int dat;

};

node s[mx];



bool cmp(node s1, node s2)

{

    return s1.dat < s2.dat;

}



int main()

{

    int n;

    cin >> n;

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

    {

        s[i].id = i;

        cin >> s[i].dat;

    }

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

    cout << s[1].id;

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

    {

        cout << ' ' << s[i].id;

    }

    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>

#include<cmath>

using namespace std;

struct student

{

	int i;

	int ai;

};

student stu[100010];



bool cmp(student& a, student& b)

{

	return a.ai < b.ai;

}



int main()

{

	int n;

	cin >> n;

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

	{

		stu[i].i = i + 1;

		cin >> stu[i].ai;

	}

	sort(stu, stu + n, cmp);

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

	{

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

	}

}

// 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 <stdlib.h>

#include <string>

#include <math.h>

#include <algorithm>

using namespace std;

const int N=100500;

pair<int,int> a[N];

int main()

{

	int n;

	cin>>n;

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

	{

		cin>>a[i].first;

		a[i].second=i+1;

	 } 

	sort(a,a+n);

	cout<<a[0].second;

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

		cout<<" "<<a[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: