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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#define ll long long 

#define MAXN 200010

using namespace std;



int n,m;



struct node{

	int pos;

	int index;

}X[100010];



bool cmp(node a,node b){

	return a.pos<b.pos;

} 



int main(){

	scanf("%d",&n);

	int x;

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

		scanf("%d",&x);

		X[i].pos=x;

		X[i].index=i;

	}

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

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

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

	}

//	printf("\n");

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

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

#define ROF(i,a,b) for(register int i=(a);i>=(b);--i)

#define pi pair<int,int>

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

#define fi first

#define se second

using namespace std;

typedef long long ll;

typedef double db;

const int maxn = 100005;

const int maxm = 100;

const int inf = 2147483647;

typedef long long ll;

const double eps = 1e-9;

const long long INF = 9223372036854775807ll;

ll qpow(ll a,ll b,ll c){ll ans=1;while(b){if(b&1)ans=ans*a%c;a=a*a%c;b>>=1;}return ans;}

struct Node{

	int v,id;

}a[maxn];

bool cmp(Node a,Node b){

	return a.v<b.v;

}

int main(){

	int n;

	scanf("%d",&n);

	FOR(i,0,n){

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

		a[i].id=i;

	}

	sort(a,a+n,cmp);

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

	printf("\n");

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include <algorithm>

#include <iostream>

#define N 100099

#define INF 0x3f3f3f3f

#define LLINF 0x3f3f3f3f3f3f3f3f

#define LL long long

using namespace std;

int n;

struct DOT

{

    int v, id;

    bool operator<(const DOT y) const

    {

        return v < y.v;

    }

} p[N];

int main()

{

    cin >> n;

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

    {

        scanf("%d", &p[i].v);

        p[i].id = i;

    }

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

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

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

    cout << endl;

    return 0;

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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



using namespace std;



using ll = long long;

using ull = unsigned long long;



const long long MOD = 1e9 + 7;





#define INPUT(x)                freopen(x,"r",stdin)

#define OUTPUT(x)               freopen (x,"w",stdout)





#define pb                      push_back

#define endl                    '\n'

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

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

#define SP(x,y)                 fixed<<setprecision((y))<<(x)

#define PI                      acos(-1.0)

#define distance(x1,y1,x2,y2)   sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1))

#define MAX                     1e9 + 9



#define taratari                ios_base::sync_with_stdio(0);cin.tie(NULL);





int main()

{

    taratari



    int n;

    cin>>n;



    vector <pair <int, int> > a;



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

    {

        int x;

        cin>>x;



        a.pb(make_pair(x,i+1));

    }



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



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

    {

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

    }





    return 0;



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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

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



using namespace std;



using ll = long long;



int main() {

    // freopen("g.txt", 'r', stdin);

    // fastio;



    int n;

    scanf("%d", &n);



    vector<pair<int, int>> arr(n);

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

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

        arr[i].second = i+1;

    }



    sort(begin(arr), end(arr));



    for (auto e : arr)

        printf("%d ", e.second);

    puts("");



    return 0;

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

using namespace std;



#define ll long long

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



int main()

{

    ll n;

    cin>>n;

    vector<ll> A;

    map<ll,ll> mp;

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

    {

        ll c;cin>>c;

        A.push_back(c);

    }



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

    {

        mp[A[i]]=i+1;

    }



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



    for(auto x: A)

    {

        cout<<mp[x]<<" ";

    }

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

#include <algorithm>

using namespace std;

struct a

{

	int num;

	int sum;

	bool operator < (const a &s)const

	{

		return sum<s.sum;

	}

	a(){num=0;sum=0;

	}

};

a s[100050];

int main()

{

	int N;

	cin>>N;

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

	{

		cin>>s[i].sum;

		s[i].num=i+1;

	}

	sort(s,s+N);

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

	{

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

	}

} 

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

#include <bits/stdc++.h>

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

#define endl '\n'

using namespace std;

int main()

{

    fastio;

    long long n,i;

    cin>>n;

    pair<long long, long long> p[n];

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

    }

    return 0;

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

using namespace std;

#define ll long long int 

#define pi pair<int,int> 

#define pb push_back

#define INF INT_MAX 

#define mod 1000000007ll

#define fi first

#define se second

#define f(i,p,q) for(int i=p;i<q;i++)

#define si(a) scanf("%d",&a)

#define sii(a,b) scanf("%d %d",&a,&b)

#define siii(a,b,c) scanf("%d %d %d",&a,&b,&c)

#define pii(a) printf("%d\n",a)

#define psi(a) printf(" %d",a)

#define poi(a) printf("%d",a)

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

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

#define Nline() printf("\n")

#define sstr(str) scanf("%s",str)

#define pstr(str) printf("%s\n",str)

#define SET(a) memset(a,-1,sizeof(a))

#define CLR(a) memset(a,0,sizeof(a))

#define vi vector<int>

#define vvi vector<vi>

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

#define SORT(v) sort(all(v))

#define RSORT(v) sort(all(v), greater<int>())

#define VI(a,n) vi a(n); rep(i,n)cin>>a[i];

#define sq(n) (n)*(n)

#define iso ios::sync_with_stdio(false); cin.tie(0);cout.tie(NULL);

bool com(pair<int,int>p,pair<int,int>pp)

{

     return p.first<pp.first;

}

int main()

{  

    int n;

    cin>>n;

    vector<pair<int,int>>v;

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

    {

        int x;cin>>x;

        v.pb({x,i});

    }

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

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

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

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

using namespace std;

int main()

{

    int n;

    cin>>n;

    map<int,int>mp;

    int a[n+1];

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

    {

        cin>>a[i];

        mp[a[i]]=i;

    }

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

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

        cout<<mp[a[i]]<<' ';

    cout<<endl;

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

using namespace std;

#define ll long long int

ll ar[500009],br[500009],fr[500009];

string s1,s2;

map<string,int>mp;

int main()

{

    ll i,j,k,e,r,n,s,d,f,g,h,u,ck=0,ck1=0,t;

    cin >> n;

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

    {

        cin >> ar[i];

        stringstream ss;

        ss << ar[i];

        ss >> s2;

        mp[s2]=i;

    }

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

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

    {

        stringstream ss1;

        ss1 << ar[i];

        ss1 >> s1;

        cout << mp[s1] << " ";

    }

    cout << endl;

}




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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

#define Mod 1000000007

#define eps 1e-6

#define ll long long

#define INF 0x3f3f3f3f

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

#define Maxn 1000000 + 10

using namespace std;

int n;

int h;

int result = 0;

map<ll,ll>id;

map<ll,ll>::iterator it;

int main()

{

    cin >> n;

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

    {

        int x;

        cin >> x;

        id[x]=i;

    }

    for(it=id.begin(); it!=id.end(); it++)//遍历即可

        cout<<it->second<<" ";

    

    cout << endl;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

#include <algorithm>

using namespace std;

struct student{

    int a;

    int b;

};

bool cmp(student a,student b){

    return a.a<b.a;

};

int main(){

    int n,i;

    cin >> n;

    student a[n];

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

        cin >> a[i].a;

        a[i].b=i+1;

    }

    sort(a,a+n,cmp);

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

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

    cout << a[n-1].b << endl;

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

}
// Slower C++ solution:
/// However long the night,

///     The dawn will break

/// ICPC next year



#include<bits/stdc++.h>

using namespace std ;

const int N = 1e5+5 ;



int n ,x ;

pair<int,int> arr[N] ;

int main(){

    scanf("%d",&n);

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

        scanf("%d",&x);

        arr[i] = {x,i+1};

    }

    sort(arr,arr+n);

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

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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



using namespace std;



int main()

{

    int n;

    cin>>n;

    vector<pair<int ,int> > v(n);

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

    {

        v[i].second=i;

        cin>>v[i].first;

    }

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

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

    {

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

    }

    cout<<endl;

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

}
// Slower C++ solution:


#include <iostream>

#include <map>



using namespace std;



int main(){

    int N; cin >> N; map<int, int> M;

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

        int A; cin >> A; M.insert(make_pair(A, i+1));

    }



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

        if (i != M.begin()) cout << ' ';

        cout << (*i).second;

    }



    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

}
// Slower C++ solution:
/******************************************

* AUTHOR : RAJAGOPALAN *

* NICK : ARNO *

* INSTITUTION : VIT *

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

#include <bits/stdc++.h>

#include <ext/pb_ds/detail/standard_policies.hpp>

#define ll long long

#define ull unsigned long long

#define pb push_back

#define mp make_pair

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

#define alli(a, n, k) (a+k),(a+n+k)

#define FP(i, a, b, k) for(__typeof(a) i = a;i < b;i += k)

#define FS(i, a, b, k) for(__typeof(a) i = a;i > b;i -= k)

#define IT(it, a) for(__typeof(a.begin()) it = a.begin();it != a.end(); ++it)

#define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>

#define eps 1e-6

#define pi 3.141592653589793

using namespace std;

using namespace __gnu_pbds;



template<class T> inline T gcd(T x, T y) { if (!y) return x; return gcd(y, x%y);}

typedef vector<int> VII;

typedef vector<ll> VLL;

typedef pair<int, int> PII;

typedef vector< pair<int, int> > VPII;

typedef vector< pair<int, PII > > VPPI;

const int MOD = 1e9 + 7;

const int INF = 1e9;



inline ll modulo(ll a, ll m)

{

    return (a % m + m) % m;

}



inline ll modInverse(ll a, ll m)

{

    assert(__gcd(a, m) == 1);

    ll m0 = m;

    ll y = 0, x = 1;



    if (m == 1)

        return 0;



    while (a > 1)

    {

        ll q = a / m;

        ll t = m;



        m = a % m, a = t;

        t = y;



        y = x - q * y;

        x = t;

    }



    if (x < 0)

        x += m0;



    return x;

}



inline ll modPow(ll x, ll y, ll m)

{ //x^y % m

    if (y == 0)

        return 1LL;

    else if (y == 1)

        return x;

    else

    {

        ll ans = modPow(x, y / 2, m) % m;

        if (y & 1)

        {

            return (((ans * ans) % m) * x) % m;

        }

        else

        {

            return (ans * ans) % m;

        }

    }

}



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

{

    ios::sync_with_stdio(false);

    cin.tie(NULL);

    int n;

    cin>>n;

    VPII arr;

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

    {

        int x;

        cin>>x;

        arr.pb({x,i});

    }

    sort(all(arr),less<PII>());

    for(auto xx:arr)

    cout<<xx.second<<' ';

    return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

using namespace std;

int main()

{

	int n;

	cin>>n;

	int arr[n+2];

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

	{

		cin>>arr[i];

	}

	priority_queue <pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>> > pq;

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

	{

		pq.push({arr[i],i});

	}

	while(pq.size()>0)

	{

		cout<<pq.top().second<<" ";

		pq.pop();

	}

	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

int n;

struct ti{

	int id,a;

}x[100010];

bool cmp(ti x,ti y){

	return x.a<y.a ;

}

int main(){

	cin>>n;

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

		cin>>x[i].a;

		x[i].id=i;	

	}

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

	for(int i=1;i<=n;i++)cout<<x[i].id<<' ';cout<<endl;

	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

#include<string>

#include<cstring>

#include<algorithm>

using namespace std;



struct point

{

	int num;

	int val;

	bool operator<(const point p)

	{

		return val<p.val;

	}

}a[100010];

int main()

{    

   int n;cin>>n;

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

    {

    	cin>>a[i].val;a[i].num=i;

	}

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

	

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

    {

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

	}cout<<endl;

   

   return 0;

} 

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

#include <vector>

#include <algorithm>

using namespace std;



struct peo {

	int no, c;

	peo() { no = 0; c = 0; }

	peo(int _n, int _c) :no(_n), c(_c) {  }

	bool operator<(const peo& p) {

		return c < p.c;

	}

};



int main() {

	int n;

	cin >> n;

	vector<peo> v;

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

		int a;

		cin >> a;

		peo p(i, a);

		v.push_back(p);

	}

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

	cout << v[0].no;

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

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

	cout << endl;



	return 0;

}

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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

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

#include <cmath>

#include <iostream>

#include <algorithm>

#include <string.h>

#include <string>

#include <map>

using namespace std;

const int maxN=1e7;

struct student{

    int n;

    int all;

}S[maxN];

bool cmp(student s1,student s2){

    return s1.all<s2.all;

}

int main(){

    int m;

    cin>>m;

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

        cin>>S[i].all;

        S[i].n=i;

    }

    sort(S+1,S+m+1,cmp);

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

        if(i==m){

            cout<<S[i].n<<endl;

        }else

        {

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

        }

        

        

    }

    

    return 0;

}


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

#include <algorithm>





using namespace std;



bool cmp(pair<int,int > x, pair<int,int > y) { 

	return x.second < y.second;

}





int main() {

	int n=0 ,tmp;

	scanf("%d",&n);

	pair<int,int > a[n];

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

		a[i].first=i+1;

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

	}

	sort(a,a+n,cmp);

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

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



return 0;

}