CodeEff/ECCO huggingface dataset:
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))

B=[]
for i in range(1,N+1):
    B.append(A.index(i)+1)

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

# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
d=[0]*N
for i in range(N):
    d[A[i]-1]=i+1

print((' '.join(map(str, d))))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

ans = []

for i in range(1, N + 1):
    ans.append(A.index(i) + 1)

ans = list(map(str, ans))
print((" ".join(ans)))

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(range(1, N + 1))

A = dict(list(zip(A, B)))
A = sorted(A.items())
ans = [str(x[1]) for x in A]


print((" ".join(ans)))
# Original solution
from operator import itemgetter
N = int(eval(input()))
A = list(map(int, input().split()))
# a= []
# for i in range(N):
#     a.append((i+1, A[i]))
#     a.sort(key=itemgetter(1))
# print(' '.join([str(i[0]) for i in a]))
a = []
for i in range(N):
    for j in range(N):
        if i+1 == A[j]:
            a.append(str(j+1))
print((' '.join(a)))


# Optimized solution
from operator import itemgetter
N = int(eval(input()))
A = list(map(int, input().split()))
# a= []
# for i in range(N):
#     a.append((i+1, A[i]))
#     a.sort(key=itemgetter(1))
# print(' '.join([str(i[0]) for i in a]))
a = [0] * N
for i in range(N):
    a[ A[i] -1 ] = str(i + 1)
print((' '.join(a)))
# Original solution
import sys
N = int(eval(input()))
l = list(map(int, input().split()))
a = []
for i in range(N):
    a.append(l.index(i+1)+1)

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

# Optimized solution
import sys
N = int(eval(input()))
l = list(map(int, input().split()))
a = [0] * N
for i in range(N):
    index =l[i] -1
    #print(index)
    a[index] = i+1
    #print(a[index])
    

print((' '.join(map(str, a))))
# Original solution
n = int(eval(input()))
s = list(map(int,input().split()))
p = []

for i in range(n):
    j = s.index(i + 1) + 1
    p.append(str(j))

print((' '.join(p)))

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
t = ['0'] * n

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

print((' '.join(t)))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

def main1(N, A):
    dic = {}
    res = ""
    for i in range(0, N):
        dic[A[i]] = i+1
    for i in range(1, N+1):
        res += " {}".format(dic[i])
    print((res[1:]))

main1(N, A)


# Optimized solution
def main1(N, A):
    dic = {}
    res = ""
    for i in range(0, N):
        dic[A[i]] = i+1
    for i in range(1, N+1):
        res += " {}".format(dic[i])
    print((res[1:]))

def main2(N, A):
    lst = list()
    res = ""
    for i in range(0, N):
        lst.append({"rank":A[i], "No":i+1})
    lst.sort(key = lambda x:x["rank"])
    for i in range(0, len(lst)):
        res += " {}".format(lst[i]["No"])
    print((res[1:]))

N = int(eval(input()))
A = list(map(int, input().split()))
main1(N, A)
#main1(3,[2,3,1])#3 1 2
#main1(5,[1,2,3,4,5])#1 2 3 4 5
#main1(8,[8,2,7,3,4,5,6,1])#8 2 4 5 6 7 3 1
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
ans = [0] * N
for i in range(1, N+1):
    tmp = A.index(i)
    ans[i-1] = tmp + 1
ans_str = [str(a) for a in ans]
print((" ".join(ans_str)))

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
ans = [0] * N
cnt = 1
for a in A:
    ans[a-1] = str(cnt)
    cnt += 1
print((" ".join(ans)))
# Original solution
n = int(eval(input()))
aList = list(map(int, input().split()))
ansList = []
for a in range(1, n + 1):
    ansList.append(aList.index(a) + 1)
print((' '.join(map(str, ansList))))

# Optimized solution
n = int(eval(input()))
aList = list(map(int, input().split()))
l = []
for i, a in enumerate(aList):
    l.append((a, i))
l = sorted(l, key=lambda x:x[0])
ansList = [a[1] + 1 for a in l]
print((' '.join(map(str, ansList))))
# Original solution
def main():
    N = int(eval(input()))
    num_list = [int(i) for i in input().split()]
    order_list = []

    for order in range(1,N+1):
        num = num_list.index(order)+1
        order_list.append(num)
    
    print((" ".join(map(str,order_list))))

if __name__ == "__main__":
    main()

# Optimized solution
def main():
    N = int(eval(input()))
    num_list = [int(i) for i in input().split()]
    order_list = [0 for i in range(N)]

    for index,num in enumerate(num_list):
        order_list[num-1] = index+1
    
    print((" ".join(map(str,order_list))))

if __name__ == "__main__":
    main()
# Original solution
import sys

input = sys.stdin.readline

def main():
    ans = 0
    n = int(input())
    o = list(map(int, input().split()))
    l = [0]*n
    for i in range(n):
        l[o[i]-1] = i+1
    for i in range(len(l)):
        if  i != len(l)-1:
            print("{} ".format(l[i]), end='')
        else:
            print(l[i])

if __name__ == '__main__':
    main()


# Optimized solution
import sys

input = sys.stdin.readline

def main():
    ans = 0
    n = int(eval(input()))
    o = list(map(int, input().split()))
    l = [0]*n
    for i in range(n):
        l[o[i]-1] = i+1
    print((" ".join(map(str,l))))
if __name__ == '__main__':
    main()
# Original solution

n=int(eval(input()))
l=[]
tem=list(map(int,input().split()))
for i in range(n):
    l.append((tem[i],i+1))
print((" ".join(list([str(x[1]) for x in sorted(l,key=lambda x: x[0])]))))


# Optimized solution

n=int(eval(input()))
l=[]
tem=list(map(int,input().split()))

print((" ".join(list([str(x[1]) for x in sorted(zip(tem,list(range(1,n+1))),key=lambda x: x[0])]))))
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
ans = ''

for i in range(1,n+1):
  if ans != '':
    ans = ans + ' '
  ans = ans + str(a.index(i)+1)
print(ans)

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
d = {}
ans = ''

for i in range(0,n):
  d[a[i]] = i+1

d_sorted = sorted(list(d.items()), key=lambda x:x[0])

for i in range(n):
  if ans != '':
    ans = ans + ' '
  ans = ans + str(d_sorted[i][1])

print(ans)
# Original solution
from collections import deque

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

for i in range(1, N + 1):
    ans.append(A.index(i) + 1)

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

# Optimized solution
from collections import deque

N = int(eval(input()))
A = list(map(int, input().split()))
A = list(enumerate(A))
A.sort(key = lambda x: x[1])

ans = deque()

for a in A:
    ans.append(a[0] + 1)

print((" ".join(map(str, ans))))
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
S =[]
for i in range(1,N+1):
  a =A.index(i)+1
  S.append(str(a))
S =' '.join(S)
print(S)
 

# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))
D = [0]*N
for i in range(N):
  a = A[i]
  D[a-1] = i+1
d = str(D[0])
for i in range(1,N):
  d += ' '+str(D[i])
print(d)
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
A_ = sorted(A)
for i in range(N):
  A_[i] = (str(A.index(A_[i])+1))
print((' '.join(A_)))

# Optimized solution
N = int(eval(input()))
A = list(map(int,input().split()))
ans = ['']*N
for id,name in enumerate(A):
  ans[name-1] = str(id+1)
print((' '.join(ans)))
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))
ans = 1
X = []
while(ans<N+1):
    for i in range(N):
        if A[i] == ans:
            ans += 1
            X.append(str(i+1))
L=' '.join(X)
print(L)

# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
X = [0 for _ in range(N)]

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

L = " ".join([str(i) for i in X])
print(L)
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
b = []
for i in range(n):
    b.append(i+1)
ans = [a.index(x)+1 for x in b]
print((' '.join(map(str,ans))))

# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
b = [0]*n
for i in range(n):
    b[a[i]-1] = i + 1
print((' '.join(map(str,b))))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

ans = []
for _ in range(N):
    index = A.index(min(A))
    ans.append(index + 1)
    A[index] = N + 1
print((' '.join(map(str, ans))))


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))

A_dict = {}
for i in range(N):
    A_dict[i+1] = A[i]

sorted_dict = sorted(list(A_dict.items()), key=lambda x: x[1])

ans = []
for t in sorted_dict:
    ans.append(t[0])
print((' '.join(map(str, ans))))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
alist = []

for i in range(1, n+1):
    alist.append(str(a.index(i)+1))

print((" ".join(alist)))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
alist = [0]*n

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

print((" ".join(alist)))
# Original solution
n = int(eval(input()))
a=list(map(int,input().split()))
j = 1
ans = list()
while j <= n:
    ans.append(a.index(j)+1)
    j = j+1
print((' '.join(map(str, ans))))


# Optimized solution
n = int(eval(input()))
a=list(map(int,input().split()))
j = 1
ans = [0] * n
while j <= n:
    ans[a[j-1]-1] =  j
    j = j+1
print((' '.join(map(str, ans))))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
new_a = []

for i in range(len(a)):
    new_a.append(str(a.index(i+1)+1))
    
print((" ".join(new_a)))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
new_a = list("0"*len(a))

for i, a_i in enumerate(a):
    new_a[a_i-1] = str(i+1)
    
print((" ".join(new_a)))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
T = []
for i in range(1,N+1):
    T.append(str(A.index(i)+1))
print((" ".join(T)))

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
T = [0 for i in range(N)]
for i in range(N):
    T[A[i] - 1] = str(i + 1)
print((" ".join(T)))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))

ans=""
for i in range(1, n+1):
  ans = ans + str(a.index(i)+1) + " "
  
print((ans.strip()))


# Optimized solution
n = int(eval(input()))
ans=[0] * (n + 1)

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

for i in range(1, n+1):
  chakujunn = a[i-1]
  ans[chakujunn] = i
  
print((" ".join(map(str,ans[1:]))))
# Original solution
from sys import stdin
input = stdin.readline


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

  order = []
  for i in range(N):
    order.append((i+1, A[i]))
  order = sorted(order, key=lambda x: x[1])
  for i in range(N-1):
    print(order[i][0], end=' ')
  print(order[N-1][0])


if(__name__ == '__main__'):
  main()


# Optimized solution
from sys import stdin
input = stdin.readline


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

  order = sorted(range(1, N+1), key=lambda i: A[i-1])

  print(*order, sep=' ')


if(__name__ == '__main__'):
  main()
# Original solution
#!/usr/bin/env python3
import sys


def solve(N: int, A: "List[int]"):
    for i in range(1, N + 1):

        if i == N:
            print(A.index(i) + 1)
        else:
            print(A.index(i) + 1, end=" ")
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, A)


if __name__ == "__main__":
    main()


# Optimized solution
#!/usr/bin/env python3
import sys


def solve(N: int, A: "List[int]"):
    l = [None] * N
    for i in range(0, N):
        l[A[i] - 1] = str(i + 1)
    print((" ".join(l)))
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word

    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, A)


if __name__ == "__main__":
    main()
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))

ans = [""]*n

for i in range(n):
    x = a[i]
    b = ans[a[i] - 1]
    c = str(i+1)
    ans[a[i]-1] = str(i+1)

print((" ".join(ans)))

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))

ans = [""]*n

for i in range(n):
    ans[a[i]-1] = str(i+1) #aのi番インデックスの値から１引いたものがans配列のインデックスになる。値は出席番号(i+1)

print((" ".join(ans)))
# Original solution
N = int(input())
A = list(map(int, input().split()))

student_dic = {}
for i in range(N):
    student_dic[A[i]] = i+1


tmp = sorted(student_dic.items())
for i in range(N):
    if i == N-1:
        print(tmp[i][1])
    else:
        print(tmp[i][1], end=" ")


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

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


for i in range(N):
    if i == N-1:
        print(student_dic[i])
    else:
        print(student_dic[i], end=" ")
# Original solution
N=int(eval(input()))
A=tuple(map(int,input().split()))

a=[]

for i in range(1,N+1):
    a.append(A.index(i)+1)

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

# Optimized solution
N=int(eval(input()))
A=tuple(map(int,input().split()))

a=[0]*N

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

print((" ".join(map(str,a))))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

order = [0] * N
flag = 0
for i in range(0, N):
    flag = A.index(min(A))
    order[i] = flag + 1
    A[flag] = N + 1

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


# Optimized solution
N = int(eval(input())) 
A = list(map(int,input().split()))
 
lis = []
for i in range(N):
    lis.append ([A[i],i+1])
 
lis.sort()
ans = []
for i in range(N):
    ans.append(lis[i][1])
 
print((" ".join(map(str,ans))))
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
sort_A = [0]*N

num = N
for i in range(N)[::-1]:
    sort_A[i] = A.index(num) + 1
    num -= 1

print((' '.join(list(map(str,sort_A)))))

# Optimized solution
from operator import itemgetter

N = int(eval(input()))
A = list(map(int,input().split()))
index_A = sorted([[i+1,x] for i,x in enumerate(A)],key=itemgetter(1))
A = [i[0] for i in index_A]

print((" ".join(list(map(str,A)))))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))

cnt = 1
ans =[0] * n

for _ in range(n):
    for i in range(n):
        if a[i] == cnt:
            ans[cnt-1] = i+1
            cnt += 1
            break

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

# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
num = list(range(1, n+1))

cin = dict(list(zip(a, num)))
ans =[]

for i in range(n):
    ans.append(cin[i+1])

print((' '.join(map(str, ans))))
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
ans=[]
for i in range(1,n+1):
    ans.append(str(a.index(i)+1))
ans=' '.join(ans)
print(ans)

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
ans={}
for i in range(1,n+1):
    ans[a[i-1]]=i
answer=[]
for i in range(1,n+1):
    answer.append(str(ans[i]))
answer=' '.join(answer)
print(answer)
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
b = []

for i in range(n):
  for j in range(n):
    if a[j] == i + 1:
      b.append(str(j+1))
      break

print((' '.join(b)))



# Optimized solution
n = int(eval(input()))
a = list(map(int,input().split()))
b = [0 for i in range(n)]

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

print((' '.join(b)))
# Original solution
n = int(eval(input()))
ai = list(map(int, input().split()))

ans = []
for i in range(1, n+1):
    ans.append(ai.index(i)+1)
ans = list(map(str, ans))
print((" ".join(ans)))    


# Optimized solution
n = int(eval(input()))
ai = list(map(int, input().split()))

ans = [None]*n

for i in range(n):
    ans[ai[i]-1] = i+1

ans = list(map(str, ans))
print((" ".join(ans)))
# Original solution
n = int(eval(input()))
ans = ""
a = list(map(int,input().split()))
for i in range(n):
    b = a.index(i+1)
    ans += str(b+1)
    if i != n-1:
        ans += " "
print(ans)

# Optimized solution
n = int(eval(input()))
b = ""
ans = [0 for i in range(n)]
a = list(map(int,input().split()))
for i in range(n):
    ans[a[i]-1] = i+1
for i in range(n):
    b += str(ans[i])
    if i != n-1:
        b += " "
print(b)
# Original solution
N = int(eval(input()))
records = [(order, index + 1) for index, order in
           enumerate(map(int, input().split(' ')))]


def get_index(record):
    order, index = record
    return str(index)


print((' '.join(map(get_index, sorted(records)))))


# Optimized solution
N = int(eval(input()))

A = tuple(map(int, input().split(' ')))
A = [(a, index) for index, a in enumerate(A, start=1)]

print((' '.join([str(index) for _, index in sorted(A)])))
# Original solution
N=int(eval(input()))
A=list(map(int,input().strip().split()))

B=[A.index(n)+1 for n in range(1,N+1)]

print((" ".join(list(map(str,B)))))

# Optimized solution
N=int(eval(input()))
A=list(map(int,input().strip().split()))

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

print((" ".join(list(map(str,B)))))
# Original solution
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	N = II()
	A = LI()
	order = [0]*N
	for i,a in enumerate(A):
		order[a-1] = i+1
	ans = ""
	for a in order:
		ans += (str(a)+" ")

	print(ans[:-1])

main()


# Optimized solution
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	N = II()
	A = LI()
	order = [0]*N
	for i,a in enumerate(A):
		order[a-1] = i+1
	order = list(map(str,order))
	print(" ".join(order))

main()
# Original solution
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]

def main():
	N = II()
	A = LI()
	order = [0]*N
	for i,a in enumerate(A):
		order[a-1] = i+1
	order = list(map(str,order))
	print(" ".join(order))

main()


# Optimized solution
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
printV = lambda x: print(*x, sep="\n")
printH = lambda x: print(" ".join(map(str,x)))
def IS(): return sys.stdin.readline()[:-1]
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LII(rows_number): return [II() for _ in range(rows_number)]
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def LLI1(rows_number): return [LI1() for _ in range(rows_number)]
mo = 10**9+7

def main():
	n = II()
	a = LI()
	ans=[]
	for i,x in enumerate(a,1):
		ans.append([i,x])
	ans.sort(key=lambda x: x[1])
	printH(row[0] for row in ans)

if __name__ == '__main__':
	main()
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
answer = []
for i in range(N):
    for j in range(N):
        if A[j] == i+1:
            answer.append(j+1)
print((' '.join(map(str, answer))))


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
B = {}
for i in range(N):
    B[A[i]] = i+1
answer = sorted(B.items())
ac=[]
for i in range(N):
    ac.append(answer[i][1])
print((' '.join(map(str, ac))))
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=[]
for i in range(n):
  b.append(a.index(i+1)+1)
print((' '.join(map(str,b))))

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=sorted(list(range(len(a))), key=lambda k: a[k])
for i in range(n):
  b[i]+=1
print((' '.join(map(str,b))))
# Original solution
import math
from math import gcd
INF = float("inf")

import sys
input=sys.stdin.readline
import itertools
from collections import Counter

def main():
    n = int(eval(input()))
    a = list(map(int , input().split()))
    ans = [0]*n
    cnt = 1
    for i in a:
        ans[i-1] =cnt
        cnt += 1
    print((" ".join(map(str,ans))))

if __name__=="__main__":
    main()


# Optimized solution
import math
from math import gcd
INF = float("inf")

import sys
input=sys.stdin.readline
import itertools
from collections import Counter

def main():
    n = int(eval(input()))
    a = list(map(int , input().split()))
    ans = [0]*n
    for i, num in enumerate(a):
        ans[num-1] = i+1
    print((" ".join(map(str,ans))))

if __name__=="__main__":
    main()
# Original solution
n = int(eval(input()))
array = list(map(int, input().split()))
map = {}
for i in range(n):
    map[array[i]] = str(i+1)
print((" ".join([map[i] for i in range(1, n+1)])))

# Optimized solution
n = int(eval(input()))
array = list(map(int, input().split()))
map = {array[i]:str(i+1) for i in range(n)}
print((" ".join([map[i] for i in range(1, n+1)])))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split(" ")))

d = {}
for a in A:
    d[A.index(a) + 1] = a

ans = [str(k) for k, _ in sorted(list(d.items()), key=lambda x: x[1])]
print((" ".join(ans)))


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split(" ")))

d = dict(list(zip(list(range(N)), A)))

ans = [str(k + 1) for k, _ in sorted(list(d.items()), key=lambda x: x[1])]
print((" ".join(ans)))
# Original solution
n = int(eval(input()))
nums = list(map(int, input().split()))
result = []

minNum = min(nums)
while(len(result) != n):
    result.append(str(nums.index(minNum) + 1))
    nums[nums.index(minNum)] = 10**5 + 1
    minNum += 1

print(((" ").join(result)))

# Optimized solution
n = int(eval(input()))
nums = list(map(int, input().split()))
pairlist = []
for i in range(len(nums)):
    pairlist.append([i, nums[i]])

sortedPairList = sorted(pairlist, key=lambda item: item[1])

result = []
for i in sortedPairList:
    result.append(str(i[0]+1))
print((" ".join(result)))
# Original solution
N = int(eval(input()))
inputData = input().split()
A = [int(x) for x in inputData]

B = [0] * N
ans = ''
for i, num in enumerate(A):
    B[num-1] = i + 1
for j in B:
    ans = ans + ' ' + str(j)
print((ans[1:]))

# Optimized solution
N = int(eval(input()))
inputData = input().split()
A = [int(x) for x in inputData]

B = [0] * N
ans = ''
for i, num in enumerate(A):
    B[num-1] = i + 1
print((' '.join(map(str, B))))
# Original solution
_  = eval(input())
A = list(map(int, input().split()))

li = list()
for i, n in enumerate(A):
    li.append((i + 1, n))

li.sort(key=lambda x: x[1])
ans = ""
for y in li:
    ans = ans.__add__(str(y[0]) + " ")

print((ans.strip()))

# Optimized solution
_  = eval(input())
A = list(map(int, input().split()))

li = sorted( enumerate(A, 1), key=lambda x: x[1])

print((" ".join([str(i[0]) for i in li])))