Problem:
 Score : 300 points    Problem Statement  Takahashi is a teacher responsible for a class of N students.  The students are given distinct student numbers from 1 to N .  Today, all the students entered the classroom at different times.  According to Takahashi's record, there were A_i students in the classroom when student number i entered the classroom (including student number i ).  From these records, reconstruct the order in which the students entered the classroom.      Constraints   1 \le N \le 10^5  1 \le A_i \le N  A_i \neq A_j  (i \neq j)  All values in input are integers.         Input  Input is given from Standard Input in the following format:  N  A_1  A_2  \ldots  A_N       Output  Print the student numbers of the students in the order the students entered the classroom.        Sample Input 1 3
2 3 1      Sample Output 1 3 1 2  First, student number 3 entered the classroom.  Then, student number 1 entered the classroom.  Finally, student number 2 entered the classroom.       Sample Input 2 5
1 2 3 4 5      Sample Output 2 1 2 3 4 5       Sample Input 3 8
8 2 7 3 4 5 6 1      Sample Output 3 8 2 4 5 6 7 3 1

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
AA = [[0,0] for i in range(N)]
for i in range(N):
  AA[i][0] = A[i]
  AA[i][1] = i + 1
B = sorted(AA)
BB = [B[i][1] for i in range(N)]
BB2 = [str(s) for s in BB]
print(" ".join(BB2))

Solution (Python):
N = int(raw_input())
A = map(int, raw_input().split())

B = [0] * N
for i,a in enumerate(A):
    B[a-1] = i+1
ans = " ".join(map(str, B))
print(ans)

Solution (Python):
import numpy as np

N = int(input())
tmp = input()
tmp_s = [int(x.strip()) for x in tmp.split(' ')]
x = np.argsort(tmp_s)

print(" ".join(repr(e) for e in x+1))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
a = [0]*(N+1)
ans = [0]*(N)

for i in range(1,N+1):
    a[i] = i


pairs = zip(A, a)
sortedpairs = sorted(pairs, key=lambda x: x[0])

for i in range(N):
    ans[i] = sortedpairs[i][1]+1


print(' '.join(map(str, ans)))

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
B=[(0,0)]*N
for i, b in enumerate(A):
    B[i]=(i+1, A[i])
B.sort( key=lambda x: x[1])

for i in range(N):
    print(B[i][0], end=" ")

Solution (Python):

import heapq
if __name__ == "__main__":
    N = int(input())
    A = list(map(int,input().split()))
    retlist = sorted(range(len(A)), key=lambda k: A[k])
    for i in range(N):
        print(retlist[i]+1,end=" ")

Solution (Python):
n = int(input())
l = list(map(int,input().split()))
q = [0]*n
for i in range(n):
  q[l[i]-1] = i+1
  
print(' '.join(map(str,q)))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
d = {}
for i in range(N):
  d[i+1] = A[i]
d_sorted = sorted(d.items(), key=lambda x:x[1])
for s in d_sorted:
  print(s[0], end =" ")

Solution (Python):
import numpy as np
 
N = int(input())
A = list(map(int, input().split()))
A = np.array(A)
 
AA = np.argsort(A) + 1

print(*AA)

Solution (Python):
import sys
N = int(input())
A = list(map(int, sys.stdin.readline().strip().split()))


school = [0] * N
j = 1
for i in A:
    school[i - 1] = j
    j += 1

print(' '.join(map(str, school)))

Solution (Python):
N=int(input())
L=list(map(int,input().split()))
ans=[0 for i in range(100010)]
d={i+1:v for i,v in enumerate(L)}
ans=sorted(d.items(), key=lambda x:x[1])
print(*[i[0] for i in ans])

Solution (Python):
n = int(input())
res = [0 for i in range(n)]

data = list(map(int, input().split()))

for key,value in enumerate(data):
  res[value-1] = str(key+1)
print(' '.join(res))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

ans = [0] *N

for i, a in enumerate(A):
    ans[a-1] = i+1

for s in ans:
    print(s, end =" ")

Solution (Python):
N=int(input())
M=list(map(int,input().split()))
k={}
for i,j in enumerate(M, start=1):
  k[j]=i
j=[]
for i in k:
  j.append(k[i])
  
print(" ".join(map(str,j)))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

dic = {}

num = 1
for i in A:
    dic[num] = i
    num += 1

dic_sorted = sorted(dic.items(), key=lambda x:x[1])


ans = ""
for i in dic_sorted:
    ans += str(i[0]) + " "

print(ans[:-1])

Solution (Python):
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys
import random
import itertools
import math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt


def LI(): return list(map(int, input().split()))


def LF(): return list(map(float, input().split()))


def LI_(): return list(map(lambda x: int(x)-1, input().split()))


def II(): return int(input())


def IF(): return float(input())


def LS(): return list(map(list, input().split()))


def S(): return list(input().rstrip())


def IR(n): return [II() for _ in range(n)]


def LIR(n): return [LI() for _ in range(n)]


def FR(n): return [IF() for _ in range(n)]


def LFR(n): return [LI() for _ in range(n)]


def LIR_(n): return [LI_() for _ in range(n)]


def SR(n): return [S() for _ in range(n)]


def LSR(n): return [LS() for _ in range(n)]


mod = 1000000007
inf = float('INF')


def A():
    a = II()
    b = a//2
    p = b/a
    if a % 2:
        print(1-p)
    else:
        print(p)

    return




def B():
    N, K = map(int, input().split())
    h = LI()
    count = 0

    for i in h:
        if i >= K:
            count += 1
        else:
            continue
    print(count)
    return




def C():
    N = II()
    A = LI()
    J = [0] * N
    for i, n in enumerate(A):
        J[n-1] = i+1
    for s in J:
        print(s, end=" ")

    return




def D():
    n, = LI()
    a = LI()
    q = []
    for ai in a:
        heappush(q, ai)
    for _ in range(m):
        heappush(q, heappop(q) / 2)
    ans = 0
    while q:
        ans += int(heappop(q))
    print(ans)
    return




def E():
    return




def F():
    return



if __name__ == '__main__':
    C()

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

order = list(zip(range(1,N+1), A))
order = sorted(order, key=lambda x: x[1])

for o in order:
    print(o[0], end=" ")
print("")

Solution (Python):
N = int(input())
A = list(map(int,input().split()))

num = [i+1 for i in range(len(A))]

order = []
for i in range(len(A)):
    order.append([A[i],num[i]])
    
order.sort()

ans = []
for i in range(len(A)):
    ans.append(str(order[i][1]))
    
print(" ".join(ans))

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
Number=[0]*n
for i in range(n):
    Number[a[i]-1]=i+1

print(" ".join(map(str,Number)))

Solution (Python):
import numpy as np
N=int(input())
A=np.array(list(map(int, input().split())))
B=[]
for i in np.argsort(A):
    B.append(i+1)
print(' '.join(list(map(str, B))))

Solution (Python):

import numpy as np

n = int(input())
a = list(map(int, input().split()))
a.insert(0, 0)
x = np.array(a)
y = list(np.argsort(x)[1::])

y = map(str, y)

print(" ".join(y))

Solution (Python):
N = int(input())
S = list(map(int,input().split(' ')))
ans = [0]*N
for i in range(N):
  ans[S[i]-1] = i+1
print(' '.join(map(str, ans)))

Solution (Python):
import sys
from collections import Counter, deque, defaultdict
from math import factorial
import heapq, bisect
import math
import itertools
sys.setrecursionlimit(10 ** 5 + 10)
INF = 10**15 +5
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))

n = INT()
a = LIST()
for i in range(n):
    a[i] = (a[i],i+1)
a = sorted(a)
for i in range(n):
    print(str(a[i][1]) + " ",end = "")

Solution (Python):
listA=[] 
while True:
    try:
        listA.append(list(map(int,input().split())))

    except:
        break;
        


N=listA[0]
i=1
order=[]
listA[1]
import numpy as np
np_=np.array(listA[1])
x=np.argsort(np_)
x1=list(map(lambda y:y+1,x))
print(*x1)

Solution (Python):
n = int(input())
order_list = list(map(int, input().split()))
dict = {}
for i, order in enumerate(order_list):
  dict[order] = i + 1
ans_list = []
for i in range(n):
  ans_list.append(str(dict[i+1]))
ans = ' '.join(ans_list)
print(ans)

Solution (Python):
n = int(input())
ls = list(map(int, input().split()))
menber = list(range(1, n+1))

dict1 = dict(zip(ls, menber))
dict1 = sorted(dict1.items(), key=lambda x: x[0])

for i in range(len(dict1)):
    print(dict1[i][1], end=' ')

Solution (Python):
N = int(input()) 
a_list = [int(i) for i in input().split()] 




arrival_list = []

import numpy as np

print(' '.join(list((np.argsort(a_list) + 1).astype(str))))

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]
b = [0] * n

for i in range(n):
    b[a[i] - 1]  = i + 1 
print(' '.join(map(str,b)))

Solution (Python):
import numpy as np
import math
import heapq

N = int(input())
A = list(input().split())
A = [[int(A[i]),i+1] for i in range(N)]
heapq.heapify(A)

ans = []
for i in range(N):
    x = heapq.heappop(A)
    ans.append(x[1])

print(*ans)

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
C = []
for _ in range(N):
  C.append([])
for i in range(N):
  C[i].append(A[i])
for j in range(N):
  C[j].append(j+1)
C.sort(key = lambda x:x[0])
B = [C[k][1] for k in range(N)]
for s in B:
  print(s,end = ' ')

Solution (Python):
N = int(input())

A = [int(a) for a in input().split()]

Ans = [0] * N

for i in range(0, N) :
    Ans[A[i] - 1] = i + 1

print(' '.join(map(str,Ans)))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
A_key = []

for _ in range(1, N+1):
  A_key.append(_)

A_dict = dict(zip(A, A_key))

for v in A_dict.values():
  print(v, end=' ')

Solution (Python):
n = int(input())
List = list(map(int, input().split()))

dic = {}

for i in range(n):
  dic[List[i]] = i +1



for i in range(n):
  if i != n-1:
    print(dic[i+1],end =' ')
  else:
    print(dic[i+1])

Solution (Python):
n = int(input())
a = input().split()
a = list(map(int, a))

r = [0] * n

for i in range(n):
  t = a[i]
  r[t-1] = str(i+1)

print(" ".join(r))

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
B = {}
for i in range(N):
  B[A[i]] = i+1
for i in B.values():
  print(i,end=" ")

Solution (Python):

N = int(input())
A = list(map(int, input().split()))

result = [0] * N

for i in range(len(A)):
    result[A[i] - 1] = i + 1

print(*result)

Solution (Python):
num_student = int(input())
attend_list = [(x, i+1) for i, x in enumerate(list(map(int, input().split(' '))))]
attend_list.sort()

print(' '.join(map(str, [tup[1] for tup in attend_list])))
exit(0)

Solution (Python):
N = int(input())
As = list(map(int, input().split(" ")))

IDs = range(1, len(As)+1)
result_dict = dict(zip(IDs,As))
result_dict = sorted(result_dict.items(), key=lambda x:x[1])
result_list = list(map(lambda x: str(x[0]), result_dict))
result = " ".join(result_list)
print(result)

Solution (Python):
n = int(input())

a = [int(x) for x in input().split(' ')]

l = list(range(0,n))

l.sort(key=lambda i: a[i])

for i in range(len(l)):
  l[i] += 1

print(*l)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
c = [0] * n
for j in range(n):
    c[a[j]-1] = j+1
print(*c)

Solution (Python):
n = int(input())
a = [int(i) for i in input().split()]

ans = [-1 for i in range(n)]
for i, c in enumerate(a):
    ans[c-1] = str(i+1)
print(' '.join(ans))

Solution (Python):
n = int(input())
a = [ int(i) for i in input().split()]
b = [""] * n

for i, ai in enumerate(a):
    b[ai-1] = str(i+1)

print(" ".join(b))

Solution (Python):


_ = int(input())
a = [(i + 1, x) for i, x in enumerate(map(int, input().split()))]


print(' '.join(map(lambda x: str(x[0]), sorted(a, key=lambda v: v[1]))))

Solution (Python):
import numpy as np
N = int(input())
A_list = list(map(int,input().split()))
res = np.argsort(A_list)

for s in res:
    print(s+1, end =" ")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans_list = [0 for i in range(n)]

for i in range(n):
    ans_list[a[i]-1] = i + 1
for i in ans_list:
    print(i, end=" ")
print()

Solution (Python):
import numpy as np
 
def solve(n, A):
    print(' '.join(list(map(lambda x: str(x+1), np.argsort(A)))))
 
n = int(input())
A = list(map(int, input().split()))
 
solve(n, A)

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
b=[]
for i in range(n):
  b+=[[i+1,a[i]]]
b.sort(key=lambda x:x[1])

for i in range(n):
  print(b[i][0],end=" ")
print()

Solution (Python):
import sys
input = sys.stdin.readline

N = int(input())

order = {}
count = 1
list = list((map(int, input().split())))
for i in list:
    order[i] = count
    count += 1


order_sorted = sorted(order.items())
print(' '.join([str(item[1]) for item in order_sorted]))

Solution (Python):
import numpy as np


N = int(input())
A = np.array([int(str) for str in input().split()])
[print(i + 1, end=' ') for i in np.argsort(A)]

Solution (Python):
n = int(input())
a_list = list(map(int, input().split()))
a_list = [(a, i+1) for i, a in enumerate(a_list)]

a_list.sort()

print(' '.join([str(i) for a, i in a_list]))

Solution (Python):
n = int(input())

A = map(int, input().split())

ans = [0] * n

for i, a in enumerate(A):
    ans[a-1] = i + 1

print(' '.join(map(str, ans)))

Solution (Python):

N = int(input())
A = list(map(int,input().split()))
B = [0]*N

for i in range(N):
    B[A[i]-1] = i+1

for s in B:
  print(s, end =" ")

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = [0 for i in range(n)]
for i in range(n):
    b[a[i] - 1] = i + 1
for i in b:
    print(i,end=" ")

Solution (Python):
n = int(input())
A = list(map(int, input().split()))
ori = []
for i in range(len(A)):
    ori.append((A[i], i+1))

d = dict(ori)
d_sort = sorted(d.items())

ans =[]
for i in range(len(A)):
    ans.append(d_sort[i][1])

print(*ans)

Solution (Python):
N = int(input())
A_list = list(map(int, input().split()))
A_sum = [[A, i + 1] for i, A in enumerate(A_list)]
A_sum.sort()
[print(a[1]) for a in A_sum]

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

dic = {}

for i in range(1, n+1):
    dic[i] = a[i-1]

out = sorted(dic.items(), key=lambda x:x[1])

for i in range(n-1):
    print(out[i][0], end=' ')
print(out[n-1][0])

Solution (Python):
import numpy as np
n=int(input())
li = list(map(int,input().split()))
x = np.argsort(li)



for i in x:
  print(i+1,end="")
  print(" ",end="")

Solution (Python):

N = int(input())
A = list(map(int, input().split()))
ans = []
for i in range(N):
  ans.append(0)
for i in range(N):
  ans[A[i] - 1] = i + 1 
ans = list(map(str, ans))
ans = " ".join(ans)
print(ans)

Solution (Python):
N = int(input())
As = list(map(int, input().split()))

result = [""]*N
for sid, rank in enumerate(As):
    result[rank-1] = str(sid+1)
print(" ".join(result))

Solution (Python):

N = int(input())
A = list(map(int,input().split()))

B = list(range(1, N+1))
mulL = []

for i in range(N):
  L = []
  L.append(B[i])
  L.append(A[i])
  mulL.append(L)
mulL.sort()
mulL.sort(key=lambda x:x[1], reverse=False)

answer = []
for i in range(N):
  answer.append(mulL[i][0])
  
print(*answer)

Solution (Python):
N = int(input())
A = [0]+list(map(int, input().split()))
print(*sorted(range(len(A)), key=lambda k: A[k])[1:])

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
d=[0]*(n+1)
for j in range(1, n+1):
  d[A[j-1]]= str(j)
print(" ".join(d[1:]))

Solution (Python):

"""
Created on Sat Apr 20 20:47:47 2019

@author: Owner
"""

import numpy as np
import sys
import collections
import scipy.misc
import math
from operator import itemgetter
import itertools
import copy
import bisect
import heapq


def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(int(i))
    i += 1
  if n > 1:
    table.append(int(n))
  return table   

def digit(i):
    if i > 0:
        return digit(i//10) + [i%10]
    else:
        return []
    
def getNearestValueIndex(list, num):
    """
    概要: リストからある値に最も近い値のインデックスを取得する関数
    @param list: データ配列
    @param num: 対象値
    @return 対象値に最も近い値
    """

    
    idx = np.abs(np.asarray(list) - num).argmin()
    return idx

def find_index(l, x, default=False):
    if x in l:
        return l.index(x)
    else:
        return default

class UnionFind(object):
    def __init__(self, n=1):
        self.par = [i for i in range(n)]
        self.rank = [0 for _ in range(n)]
        self.size = [1 for _ in range(n)]

    def find(self, x):
        """
        x が属するグループを探索
        """
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.par[x]

    def union(self, x, y):
        """
        x と y のグループを結合
        """
        x = self.find(x)
        y = self.find(y)
        if x != y:
            if self.rank[x] < self.rank[y]:
                x, y = y, x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1
            self.par[y] = x
            self.size[x] += self.size[y]

    def is_same(self, x, y):
        """
        x と y が同じグループか否か
        """
        return self.find(x) == self.find(y)

    def get_size(self, x):
        """
        x が属するグループの要素数
        """
        x = self.find(x)
        return self.size[x]
    

"""
N, X = map(int, input().split())

x = list(map(int, input().split()))

P = [0]*N
Y = [0]*N
for n in range(N):
    P[n], Y[n] = map(int, input().split())


dp = np.zeros((N+1, 4,4,4))
    
all(nstr.count(c) for c in '753')


ABT = zip(A, B, totAB)
result = 0

sorted(ABT,key=itemgetter(2))
A, B, totAB = zip(*ABT)
A.sort(reverse=True)


(x >> i) & 1


dp = [np.inf]*N
for n in range(N):
    if n == 0:
        dp[n] = 0
    else:
        for k in range(1,K+1):
            if n-k >= 0:
                dp[n] = min(dp[n], dp[n-k] + abs(h[n]-h[n-k]))
            else:
                break

add = 1 
res = 0
sums = [0]*(len(nums)+1)
for i in range(len(nums)):
    sums[i+1] = sums[i] + nums[i]
for i in range(0, len(nums), 2):
    left = i
    right = min(i+add, len(nums))
    tmp = sums[right] - sums[left]
    res = max(tmp, res)


li, ri = bisect.bisect_left(p_ac, l[i]-1), bisect.bisect_right(p_ac, r[i]-1)    


org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)




    for h in range(0,H):
        for w in range(0,W):
            if h == 0 and w == 0:
                pass
            elif h == 0:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h-1][W-w]+1)
            elif w == 0:   
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1)
            else:
                D[H-h-1][W-w-1]= min(D[H-h-1][W-w-1], D[H-h][W-w-1]+1, D[H-h-1][W-w]+1, D[H-h][W-w]+2)
            d_max = max(D[H-h-1][W-w-1], d_max)

"""

N = int(input())
A = list(map(int, input().split()))

    
def main():
    C = A
    B = [n for n in range(1,N+1)]
    
    CB = zip(C, B)
    
    CB = sorted(CB,key=itemgetter(0))
    
    res = [CB[n][1] for n in range(N)]

    print(*res, sep=" ")            
                
                
            
            
                

    
if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
arr = list(map(int,input().split()))

dic = {arr[i]:i+1 for i in range(n)}
sol = [dic[i+1] for i in range(n)]

print(*sol)

Solution (Python):

n= int(input())
a = input()
list1 = list(map(int,a.split()))
list2 = [0]*n
for i in range(n):
    list2[list1[i]-1] = i+1

print(" ".join(map(str,list2)))

Solution (Python):
N = int(input())
jun = [0] * N
for i, num in enumerate(input().split()):
		jun[int(num)-1] = i+1

for j in jun:
		print(j, end=' ')

Solution (Python):
n = int(input())
a = list(map(int, input().split()))

o = sorted(range(len(a)), key=lambda k: a[k])

print(" ".join(str(e+1) for e in o))

Solution (Python):
import numpy as np

n = int(input())
A = list(map(int, input().split()))
a = np.argsort(A)
print(' '.join(map(str, a+1)))

Solution (Python):
def main(n,a_list):

    i = 0
    list = [0] * n
    while i < n:
        list[a_list[i] - 1] = i + 1
        i += 1

    i = 0
    while i < n:
        print(list[i], end="")
        if not i == n - 1:
            print(' ', end="")
        i += 1


if __name__ == '__main__':
    n = int(input())
    a_list = list(map(int, input().split()))
    main(n, a_list)

Solution (Python):
N=int(input())
dict={}
ans=''
A=map(int,input().split())
for num,i in enumerate(A):
    dict[i]=num
for j in sorted(dict):
    ans+=str(dict[j]+1)+' '
print(ans)

Solution (Python):
N = int(input())
A_list = list(map(int,input().split()))
result_list = [0]*N
for i, val in enumerate(A_list):
    result_list[val-1] = i+1
print(*result_list)

Solution (Python):


n = int(input())
a = list(map(int, input().split()))

b = [0] * n
for i in range(n):
    b[a[i]-1] = i + 1

for i in range(n):
    print(b[i])

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
import numpy as np
a = np.array(a)

c = np.argsort(a) + 1
for i in range(n):
    print(c[i], end=" ")

Solution (Python):
import numpy as np
N = int(input())
A = list(map(int, input().split()))
B = np.argsort(A)+1
print (' '.join(map(str,B)))

Solution (Python):
import numpy as np
n = int(input())
a = list(map(int, input().split()))
b = np.argsort(a)
for i in range(n):
    print(b[i]+1)

Solution (Python):
N=int(input())
A=list(map(int, input().split()))
B=[0]*N

for i in range(1,N+1):
  c=A[i-1]
  B[c-1]=i

print(' '.join(map(str, B)))

Solution (Python):
import numpy as np
n=int(input())
A=list(map(int, input().split()))
Aarr = np.array(A)
Asort=Aarr.argsort()+1
print(*Asort)

Solution (Python):
n = int(input())
order_dict = {i+1:int(j) for i, j in enumerate(input().split())}

order_dict_sorted = sorted(order_dict.items(), key=lambda x:x[1])

for i in order_dict_sorted:
  print(i[0], end = ' ')

Solution (Python):
n = int(input())
b = [0] * n
a = input().split(" ")
for i in range(n):
	b[int(a[i])-1] = i+1
for i in range(n):
	print(b[i], end=" ")

Solution (Python):
N = int(input())
lis = [0]*N
for i, a in enumerate(input().split()):
    lis[int(a)-1] = str(int(i)+1)
print(' '.join(lis))

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]

values = [int(i) for i in range(1,len(A)+1)]
A_list = dict(zip(A, values))
ans = []
for i in range(1,N+1):
  ans.append(A_list[i])
print(" ".join(map(str,ans)))

Solution (Python):
N = int(input())
A = map(int,input().split())

ans = [0]*N
for i,a in enumerate(A):
    ans[a-1] = i+1
print(' '.join(map(str,ans)))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
Ans = [0] * (N)
for i in range(N):
    Ans[A[i]-1] = i+1

print(*Ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
a = [0 for _ in range(N)]

for i in range(N):
    a[A[i]-1] = i
for i in range(N):
    print(a[i]+1, end=' ')

Solution (Python):
from collections import OrderedDict
if __name__ == "__main__":
    N = int(input())
    A = list(map(int, input().split()))

    dic = OrderedDict(zip(A, range(1, N+1)))

    for i in range(1, N+1):
        print(dic[i])

Solution (Python):
import sys
import math
from copy import deepcopy
from collections import deque, defaultdict
from operator import mul
from functools import reduce
sys.setrecursionlimit(20000000)




def main():
    n = int(input())

    stu = defaultdict(int)

    count = 1
    for o in input().split():
        stu[count] = int(o)
        count += 1

    stu = sorted(stu.items(), key=lambda x: x[1])

    ans = []
    for s in stu:
        ans.append(s[0])

    print(*ans, sep=' ')


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]

order = [idx for idx, value in sorted(enumerate(A), key=lambda item: item[-1])]

for idx in order:
    print(idx+1, end=' ')

Solution (Python):
N=int(input())
A=list(map(int,input().split()))

ans=[0]*N
for i in range(1,N+1):
  ans[A[i-1]-1]=i
  
print(" ".join(map(str,ans)))

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
l = [[0,0]]*n
for i in range(n):
    l[i] = [a[i],i+1]
l.sort()
ans = [0]*n
for i in range(n):
    ans[i] = str(l[i][1])
print(' '.join(ans))

Solution (Python):
import sys
N = int(input())
A = [int(v) for v in sys.stdin.readline().split()]

Ax = list(zip(range(1, N + 1), A))

Ax.sort(key = lambda x: x[1])

result = [r[0] for r in Ax]
for r in result:
    print(str(r) + ' ', end="")
print()

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
lists = list(range(1,N+1))
c = list(zip(A,lists))
c.sort()
ans,m = zip(*c)
ans_str = map(str,m)
mojiretu = " ".join(ans_str)
print(mojiretu)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = []
for i in range(n):
    b.append([a[i], i+1])
b = list(sorted(b))
for i in range(n):
    print(b[i][1], end=" ")
print("")

Solution (Python):
import sys

stdin = sys.stdin

ns = lambda : stdin.readline().rstrip()
ni = lambda : int(ns())
na = lambda : map(int, stdin.readline().split())

def main():
  n = ni()
  a = list(na())
  d = {}
  for i, a in enumerate(a):
    d[a] = i+1
  res = []
  for i in range(n):
    res.append(d[i+1])
  print(*res)

main()

Solution (Python):
N = int(input())
As = list(map(int,input().split()))



tAs = []
for i,A in enumerate(As):
	tAs.append((A,i+1))
	
tAs = sorted(tAs, key=lambda x: x[0])

for tA in tAs:
	print(tA[1],end=" ")
print()

Solution (Python):
n = int(input())
*a, = map(int, input().split())
print(' '.join([str(v[0] + 1) for v in sorted(enumerate(a), key=lambda x: x[1])]))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
import numpy as np
A = np.array(A)
result = A.argsort()
for i,r in enumerate(result):
    if i+1 == N:
        print(r+1)
    else:
        print(r+1,end=' ')

Solution (Python):
num = int(input())
list = [int(item) for item in input().split()]

order = dict(zip(range(1,num+1), list))
p_order = sorted(order.items(), key=lambda x:x[1])



for i in [item[0] for item in p_order][:-1]:
    print(str(i) + ' ', end='')
print([item[0] for item in p_order][-1])

Solution (Python):

N = int(input())

split = input().split(" ")
Ai = {}

for i in range(N):
  Ai[split[i]] = i+1

  
for i in range(N):
  print(Ai[str(i+1)], end=" ")

Solution (Python):

n = int(input())
a = list(map(int, input().split()))

stu = [0] * n

for i in range(n):
    stu[a[i] - 1] = i + 1

print(*stu)

Solution (Python):
n = int(input())
s = list(map(int, input().split()))

dic = {}
for i in range(1, len(s)+1):
    dic[i] = s[i-1]

result = sorted(dic.items(), key=lambda x: x[1])
result = [str(d[0]) for d in result]
print(' '.join(result))

Solution (Python):
import sys

n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().split()))
b = [0]*n

for i in range(n):
	b[a[i]-1] = i+1 
print(*b)

Solution (Python):
N = int(input())

mylist = list(map(int, input().split()))

mycnt = 0

myans = [0 for n in range(N+1)]

for i in range(N):
    myans[mylist[i]] = i+1
    
    
print(' '.join(map(str,myans[1:])))

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
numlist = [n+1 for n in range(N)]
atlist = [[x,y] for x, y in zip(A, numlist)]

sortlist = sorted(atlist)
print(' '.join(map(str, [x[1] for x in sortlist])))

Solution (Python):
N = int(input())
A = map(int, input().split())
ans = [i for _, i in sorted(zip(A, list(range(1, N+1))))]
print(*ans)

Solution (Python):
n=int(input())
s=[]
s=list(map(int,input().split()))

l=[]
for i in range(n):
  l.append([s[i],i])

l.sort()

for i in range(n):
  print(l[i][1]+1,end=" ")

Solution (Python):
n = int(input())
t=list(map(int,input().split()))

d = list(range(1,n+1)) 
s = []
count = 1

c = zip(t, d)

c = sorted(c)

t, d = zip(*c)




print(*d)

Solution (Python):
N = int(input())

students = [[(i+1)] for i in range(N)]

A = list(map(int, input().split()))
for i in range(N):
    students[i].append(A[i])

students.sort(key=lambda x: x[1])

ans = ""
for student in students:
    ans += str(student[0]) + " "
    
ans = ans.rstrip()

print(ans)

Solution (Python):
n = int(input())
a = list(map(int,input().split()))
p = []
for i,j in enumerate(a):
    p.append([i,j])
p.sort(key=lambda x:x[1])
for i in p:
    print(i[0]+1)

Solution (Python):
n = map(int, input().split())
l = list(map(int, input().split()))

kl = {str(i):v for i,v in enumerate(l)}

ans = sorted(kl.items(), key=lambda x:x[1])
for i in ans:
    print(int(i[0])+1, end=" ")

Solution (Python):
n = int(input())
A = list(map(int, input().split()))

_a = []
for i in range(len(A)):
  _a.append([i+1, A[i]])
srt_a = sorted(_a, key=lambda x:x[1])

ans = []
for aa in srt_a:
  ans.append(aa[0])
print(*ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))

Ans = list(range(N))

for i in range(N):
    Ans[A[i]-1] = i+1

print(*Ans)

Solution (Python):
n = int (input())
a = list(map(int,input().split()))
ans = []
tmp = 0
for hoge in range(n):
         ans.append(0)
for i in range(n):
         tmp = a[i]-1
         ans[tmp] = i+1
print(*ans)

Solution (Python):
def solve():
    N = int(input())
    input_temp = list(map(int, input().split()))
    dictionary = {}
    for i in range(N):
        dictionary[input_temp[i]] = i+1

    for i in range(1,N+1):
        print(dictionary[i],end=" ")
    print("")

solve()

Solution (Python):
N=int(input())
A=list(map(int,input().split()))
num=[]
for i in range(N):
  num.append(i+1)
student=dict(zip(A,num))
sorted(student.keys())
for i in range(N):
  print(student[i+1],end=" ")

Solution (Python):
n = int(input())
a_li = list(map(int,input().split()))

new_a = []
for i in range(n):
    new_a.append([i + 1, a_li[i]])

new_a.sort(key=lambda x:x[1])
for i in range(n):
    print(new_a[i][0], end="")
    if i != n - 1:
        print(" ", end="")

Solution (Python):
N = int(input())
A = [int(a) for a in input().split()]

d = dict()
for i in range(N):
    d[i + 1] = A[i]

for k, v in sorted(d.items(), key=lambda  x: x[1]):
    print(str(k), end=" ")

Solution (Python):
N = input();
A = list(map(int, input().split()))
A_map = {}
i = 0
for a in A:
  A_map[i+1] = a
  i += 1

res = []
for k, v in sorted(A_map.items(), key=lambda x: x[1]):
  print(k, end=" ")

Solution (Python):
N = int(input())
A = map(int, input().split())
result = [0] * N
for i, j in enumerate(A):
    result[j-1] = i + 1
print(' '.join(map(str, result)))

Solution (Python):
N = int(input())
vA = list(map(int, input().split()))

vR = [""] * N

for i, a in enumerate(vA):
    vR[a-1] = str(i + 1)

print(" ".join(vR))

Solution (Python):
N = int(input())
a = [int(i) for i in input().split()]

a.insert(0,0)
result = []

tmp = []
for i in range(N+1):
  tmp.append([a[i],i])

tmp_sorted = sorted(tmp)

for i in range(1,N+1):
  result.append(tmp_sorted[i][1])

print(*result)

Solution (Python):
n = int(input())
a = list( map(int, input().split())) 

from collections import defaultdict
d = defaultdict(list)

for i in range(n):
    d[a[i]] = i 

for i in range(1, n+1):
    print(d[i]+1, end=' ')

Solution (Python):
N = int(input())
A = list(map(int,input().split()))
B = [1] * N
for i in range(N):
  b = A[i]
  B[b-1] = B[b-1] + i
print(*B, sep=" ")

Solution (Python):
import numpy as np
n = int(input())
a = np.array([int(i) for i in input().split()])
print(" ".join([str(i+1) for i in np.argsort(a)]))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = [i+1 for i in range(n)]
a_dict = dict(zip(a, b))
ans = [''] * n
for i, (a_, b_) in enumerate(sorted(a_dict.items())):
    ans[i] = str(b_)
print(' '.join(ans))

Solution (Python):
n = int(input())
a = list(map(int,input().split()))

res = [0]*n
for i in range(n):
    res[a[i]-1] = i+1
for e in res:
    print(e,end = ' ')