stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include<iostream>

using namespace std;

const int N=22e4;



int a[N],r[N];

bool cmp(int x,int y){

	return a[x]<a[y];

}

int main(){

	ios::sync_with_stdio(0);

	int n;

	cin>>n;

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

		cin>>a[i];

		r[i]=i;

	}

	sort(r,r+n,cmp);

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

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

	return 0;

}
// Slower C++ solution:
#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;

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

}
// Slower C++ solution:
#include<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;

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

}
// Slower C++ solution:
/*|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 << " ";

    }



}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

typedef long long ll;

using namespace std;

 

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

const int OO = 0x3f3f3f3f;

const double EPS = 1e-3;

 

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

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

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

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

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

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

typedef pair <int,int> pii ;

typedef vector < pii > vii ;

typedef vector < int > vi;

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

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

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

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

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

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

 







int n ;



 

int main()

{

	

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

 

    

    scanf("%d", &n);

    pii a[N];

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

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

        a[i].second = i+1;

    }

    sort(a , a+n);

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

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

    puts("");





    return 0;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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



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

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

}
// Slower C++ solution:
#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;

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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



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;

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

}
// Slower C++ solution:
#include <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;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

}
// Slower C++ solution:
#include <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;

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

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;

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

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;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

}
// Slower C++ solution:
//#pragma GCC optimize(2)

//#pragma G++ optimize(2)

//#include <bits/stdc++.h>

#include <iostream>

#include <cstdio>

#include <cstdlib>

#include <cmath>

#include <cstring>

#include <string>

#include <climits>

#include <algorithm>

#include <queue>

#include <vector>

using namespace std;



const int maxn=100000+10;

struct node{

    int key;

    int id;

};

node a[maxn];

int n;

bool comp(node _a,node _b){

    return _a.key<_b.key;

}

int getint(){

    int x=0,s=1; char ch=' ';

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

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

    return x*s;

}

int main(){

    //ios::sync_with_stdio(false);

    //cin.tie(0);

    cin>>n;

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

        int x; cin>>a[i].key;

        a[i].id=i;

    }

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

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

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

    }

    cout<<endl;

    return 0;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

#include<cstdlib>

#include<cstdio>

#include<cstring>

#include<cmath>

#include<algorithm>

#include<iomanip>

using namespace std;

#define rep(i,s,t) for(int i=s;i<=t;i++)

#define mem(a,s) memset(a,s,sizeof(a))

typedef long long LL;

const int N=1e5+10;

int n;

pair<int, int> a[N];

int main(){

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

    cin>>n;

    rep(i,1,n){

        cin >> a[i].first;

        a[i].second = i;

    }

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

    cout << a[1].second;

    rep(i,2,n){

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

    }

    return 0;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

#include<algorithm>

using namespace std;

struct student

{

	int num;

	int total;

}s[100100];

bool cmp(student a,student b)

{

	if(a.total<b.total)

	return true;

	else

	return false;

}

int main()

{

	int n;

	cin>>n;

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

	{

		s[i].num=i;

		cin>>s[i].total;

	}

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

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

	{

		if(i!=n)

		{

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

		}

		else

		{

			cout<<s[i].num;

		}

	}

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

#include <cstdio>

#include <cstring>

#include <iostream>

#include <string>

using namespace std;

int n;

struct st

{

    int s, c;

    bool operator<(const st &a) const

    {

        return s<a.s;

    }

}a[100010];

int main()

{

 

    scanf("%d", &n);

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

    {

        a[i].c = i;

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

    }

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



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

    {

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

    } 

    return 0;

}

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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

#include<algorithm>

using namespace std;



struct st

{

    int id;

    int num;

    bool operator<(const st& p)

    {

        return num<p.num;

    }

};

st a[100000+10];

int main()

{

    int N;

    cin>>N;

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

    {

        a[i].id = i;

        cin>>a[i].num;

    }

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

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

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

}


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

#include <algorithm>



using namespace std;



struct Stu

{

    int num, rank;

    bool operator < (const Stu& x)const {

        return rank < x.rank;

    }

}stu[100010];

int n;



int main()

{

    scanf("%d", &n);

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

    {

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

        stu[i].num = i + 1;

    }

    sort(stu, stu + n);

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

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

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

#include <stdio.h>

#include <algorithm>

#include <string.h>

using namespace std;



struct node{

	int i,ai;

	bool operator < (node t){

		return ai<t.ai;

	}

};



const int nmax=1e5+5;

int n;



node str[nmax];



int main(){

	scanf("%d",&n);

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

		str[i].i=i;

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

	}

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

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

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

	}

	return 0;

}

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

}