CodeEff/ECCO huggingface dataset:
# Original solution
import sys

N = int(sys.stdin.readline())
A = list(map(int, sys.stdin.readline().split()))

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

# Optimized solution
import sys

N = int(sys.stdin.readline())
A = list(map(int, sys.stdin.readline().split()))

ans = [None]*N
for i, order in enumerate(A, 1):
        ans[order-1] = i
print((" ".join(map(str, ans))))
# Original solution
n = int(input())
a = list(map(int, input().split()))

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

print(a.index(n) + 1)


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

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

print(*newa, sep=" ")
# Original solution
import copy
N=int(eval(input()))
L=[int(x) for x in input().split()]
L0=copy.copy(L)
L.sort()
Ans=[]

for i in range(N):
	for j in range(N):
		if L[i]==L0[j]:
			Ans.append(j+1)

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

# Optimized solution
import copy
N=int(eval(input()))
L=[int(x) for x in input().split()]
Ans=[0]*N

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

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

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
result = [0] * N
for i in range(N):
	result[A[i]-1] = str(i+1)
s = ' '.join(result)
print(s)
# Original solution
_n = int(eval(input()))
_records = list(map(int, input().split()))
_order = []
_rank = 1
while len(_order) < _n:
  for _i in range(_n):
    if _records[_i] == _rank:
      _order.append(_i + 1)
      _rank = _rank + 1
      
print((" ".join(map(str, _order))))

# Optimized solution
_n = int(eval(input()))
_records = list(map(int, input().split()))
_order = [0] * _n
_rank = 1
for _i in range(_n):
  _order[_records[_i] - 1] = _i + 1
      
print((" ".join(map(str, _order))))
# Original solution
N = int(eval(input()))
A = input().split()
B = []
for i in range(1, N+1):
    I = str(i)
    B.append(str(A.index(I)+1))
B = " ".join(B)
print(B)

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

reply = []
for i in range(len(a_list)):
    reply.append(str(a_list.index(i+1)+1))

print((' '.join(reply)))

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

reply = [None for i in range(len(a_list))]

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

print((' '.join(reply)))
# Original solution

N= int(eval(input()))
A=[[int(i), ind] for ind, i in enumerate(input().split())]

ans=""
A=sorted(A)
for i in range(N):
    ans=ans+str(A[i][1]+1)+" "
print((ans[:-1]))

# Optimized solution

N= int(input())
A=[[int(i), ind] for ind, i in enumerate(input().split())]

A=sorted(A)
for i in range(N-1):
    print(A[i][1]+1, end=" ")
print(A[N-1][1]+1)
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
List = [0]*N

for i in range(N):
  List[i] = str(A.index(i+1)+1)



print((' '.join(List)))


# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
List = [0]*N


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

  
print((" ".join(List)))
# Original solution
from operator import itemgetter
n = int(eval(input()))
lst = list(map(int, input().split()))
lst2 = []
for i in range(n):
  lst2.append((i + 1, lst[i]))
lst2.sort(key=itemgetter(1))
s = ''
for i in lst2:
  s = s + str(i[0]) + ' '
print((s[:-1]))

# Optimized solution
n = int(eval(input()))
lst = list(map(int, input().split()))
dic = {}
for i in range(n):
  dic[lst[i]] = i + 1
s = ''
for i in range(n):
  s += str(dic[i + 1]) + ' '
print((s[:-1]))
# Original solution
N = int(input())
A = list(map(int, input().split()))
ans = list(range(1, N+1))

for i in range(0, N):
    for j in range(N-1, i, -1):
        if A[j] < A[j-1]:
            A[j], A[j-1] = A[j-1], A[j]
            ans[j], ans[j-1] = ans[j-1], ans[j]

print(*ans, sep=" ")


# Optimized solution
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, sep=" ")
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
B = list()
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()))
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 i in range(1,n+1):
  ans.append(str(a.index(i)+1))
  
print((" ".join(ans)))

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

for i in a:
  num[i-1]=count
  count=int(count)
  count+=1
  count=str(count)
  
print((" ".join(num)))
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=[0]*n
for index,number in enumerate(a):
  b[number-1]=str(index+1)
print((" ".join(b)))

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

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

# Optimized solution
def main():
  import sys
  n=int(eval(input()))
  a=tuple(map(int,sys.stdin.readline().split()))
  b=[0]*n
  i=1
  for index in a:
    b[index-1]=str(i)
    i+=1
  print((" ".join(b)))
if __name__=="__main__":
  main()
# Original solution
def main():
  n, *a = list(map(int, open(0).read().split()))
  b=[None]*n
  i=1
  for index in a:
    b[index-1]=i
    i+=1
  print((" ".join(map(str,b))))
if __name__=="__main__":
  main()

# Optimized solution
def main():
  import sys
  
  n=int(eval(input()))
  a=tuple(map(int,sys.stdin.readline().split()))
  b=[None]*n
  
  for number,index in enumerate(a,1):
    b[index-1]=number
  
  print((" ".join(map(str,b))))
  
if __name__=="__main__":
  main()
# Original solution
def main():
  import sys
  n=int(eval(input()))
  a=tuple(map(int,sys.stdin.readline().split()))
  b=[None]*n
  i=1
  for j in a:
    b[j-1]=i
    i+=1
  print((" ".join(map(str,b))))
if __name__=="__main__":
  main()

# Optimized solution
def main():
  import sys
  numberOfStudent=int(eval(input()))
  orderOfArrive=tuple(map(int,sys.stdin.readline().split()))
  studentArrive=[None]*numberOfStudent
  count=1
  for arrive in orderOfArrive:
    studentArrive[arrive-1]=count
    count+=1
  print((" ".join(map(str,studentArrive))))
if __name__=="__main__":
  main()
# Original solution
def main():
  import sys
  a=int(eval(input()))
  b=tuple(map(int,sys.stdin.readline().split()))
  c=[None]*a
  d=1
  for e in b:
    c[e-1]=d
    d+=1
  print((" ".join(map(str,c))))
if __name__=="__main__":
  main()

# Optimized solution
def main():
  import sys
  a=int(eval(input()))
  b=tuple(map(int,sys.stdin.readline().split()))
  c=[None]*a
  d=1
  for e in b:
    c[e-1]=d
    d=d+1
  print((" ".join(map(str,c))))
if __name__=="__main__":
  main()
# Original solution
N = int(eval(input()))
people = list(map(int, input().split()))
order = [people.index(i)+1 for i in range(1, N+1)]
print((" ".join(map(str, order))))

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

for i in range(n):
    cnt += 1
    ind = a.index(cnt)
    ans.append(str(ind + 1))

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

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

for i in a:
    cnt += 1
    ans[i-1] = str(cnt)

print((" ".join(ans)))
# Original solution
if __name__ == '__main__':
    N = int(eval(input()))
    order_list = list(map(int, input().split()))
    present_list = list()

    for i in range(1, (N+1)):
        present_list.append(order_list.index(i) + 1)

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

# Optimized solution
if __name__ == '__main__':
    N = int(eval(input()))
    order_list = list(map(int, input().split()))
    present_list = list(range(1, N+1))
    temp = list(zip(order_list, present_list))
    temp = sorted(temp)
    order_list, present_list = list(zip(*temp))
    print((' '.join(map(str,present_list))))
# Original solution
N = int(input())
A = list(map(int,input().split()))

for i in range(1,N):
    print(A.index(i) + 1,end=' ')
print(A.index(N) + 1)


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

n = int(eval(input()))
list = []

idx = 1
for count_str in input().split():
    count = int(count_str)
    heapq.heappush(list, (count, idx))
    
    idx += 1

print((" ".join([ str(heapq.heappop(list)[1]) for _ in range(n) ])))


# Optimized solution
import heapq

n = int(eval(input()))
priority_list = []

student = 0
for priority in list(map(int, input().split())):
    student += 1
    priority_list.append((priority, str(student)))

heapq.heapify(priority_list)

print((' '.join([ heapq.heappop(priority_list)[1] for _ in range(n) ])))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
x = []
x = [0 for i in range(n)]
for j in range(n):
    x.pop(a[j] - 1)
    x.insert(a[j] - 1, j + 1)
print((" ".join(map(str, x))))


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

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
lis = [0] * N
k = 1
for i in A:
  lis[i-1] = k
  k += 1
lis = list(map(str, lis))
ans = " ".join(lis)
print(ans)
# Original solution
N = int(eval(input()))
a = list(input().split())
s = [a.index(str(i))+1 for i in range(1,N+1)]
result = " ".join(map(str, s))
print(result)


# Optimized solution

N = int(eval(input()))
a = list(map(int, input().split()))
s = [-1]
s.extend(0 for _ in range(N))

for i, item in enumerate(a):
    s[item] = i+1

result = " ".join(map(str, s[1:]))
print(result)
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
# C = [str(i) for j in range(1, N+1) for i in A if i == j]
C = [str(A.index(i)+1) for i in range(1,N+1)]
L = ' '.join(C)
print(L)

# Optimized solution
N = int(eval(input()))
A = list(map(int, input().split()))
# C = [str(i) for j in range(1, N+1) for i in A if i == j]
# index と　value を入れ替える
C = [0]*N
# print(C)
for k in range(N):
    C[A[k]-1] = str(k+1)
    # C[k] = k
# print(C)
# C = [str(A.index(i)+1) for i in range(1,N+1)]
L = ' '.join(C)
print(L)
# Original solution
N = int(eval(input()))
A = enumerate(map(int, input().split()), 1)

def sort(N, A):
    l = [None] * N
    setitem = l.__setitem__
    for i, v in A:
        setitem(v-1, str(i))
    return l

print((' '.join(sort(N, A))))

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

def sort(N, A):
    l = [None] * N
    for i, v in A:
        l[v-1] = str(i)
    return l

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

def find(target, list):
    for i in range(len(list)):
        if list[i] == target:
            return i+1

out = []
for j in range(1, n+1):
    out.append(find(j, a))

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


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

out = sorted(list(range(1, len(a)+1)), key=lambda i: a[i-1])
print((" ".join(map(str, out))))
# Original solution
n=int(eval(input()))
a=[int(i)for i in input().split()]
res=[1 for i in range(n)]
for i in range(n):
    res[i]+=a.index(i+1)
print((" ".join(map(str,res))))

# Optimized solution
n=int(eval(input()))
a=[int(i)for i in input().split()]
res=[0 for i in range(n)]
for i in range(n):
    res[a[i]-1]=i+1
print((" ".join(map(str,res))))
# Original solution
def resolve():
    n = int(eval(input()))
    a = list(map(int, input().split()))
    h = []
    for i, ai in enumerate(a):
        h.append([i, ai])
    h.sort(key=lambda x: x[1])
    ans = " ".join([str(i + 1) for i, _ in h])
    print(ans)


if __name__ == "__main__":
    resolve()


# Optimized solution
def resolve():
    n = int(eval(input()))
    a = list(map(int, input().split()))
    b = sorted([(i, ai) for i, ai in enumerate(a)], key=lambda x: x[1])
    print((" ".join([str(i + 1) for i, _ in b])))


if __name__ == "__main__":
    resolve()
# Original solution
N = int(eval(input()))
a = ""
student = list(map(int,input().split()))
for i in range(N):
    a += " " + str(student.index(i+1) + 1)
a = list(a.split(" "))
a.pop(0)
print((" ".join(a)))

# Optimized solution
N = int(eval(input()))
student = list(map(int,input().split()))
A = [0] * N
for i in range(N):
    A[student[i]-1] = i+1
A = list(map(str,A))
print((" ".join(A)))
# Original solution
N = int(eval(input()))
A = []#生徒たちが出席した順番
students = []#生徒たちの番号
rank_sort = []#出席した順の生徒たちの番号

i = 0
for x in input().split():
    i += 1
    A.append(int(x))
    students.append(int(i))

rank = 1
n = N
for i in range(N):
    for j in range(n):
        if A[j] == rank:
            rank_sort.append(students[j])
            del A[j]
            del students[j]
            break
    rank += 1
    n -= 1
print((' '.join(map(str,rank_sort))))

# Optimized solution
N = int(eval(input()))
A = []#生徒たちが出席した順番
rev = [0]*N #早く来た順の生徒の番号

for x in input().split():
    A.append(int(x))

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

print((' '.join(map(str,rev))))
# Original solution
num = int(eval(input()))
li = list(map(int, input().split()))

number = list(range(num))
data = dict(list(zip(number, li)))
data_sorted = sorted(list(data.items()), key = lambda x:x[1])
data_key = [str(i[0] + 1) for i in data_sorted]
print((" ".join(data_key)))

# Optimized solution
x = int(eval(input()))
num_list = list(map(int, input().split()))

li = list("A" * x)

for index, num in enumerate(num_list):
	li[num-1] = str(index+1)

print((" ".join(li)))
# Original solution
from collections import deque
N = int(eval(input()))
A = [int(i) for i in input().split()]

s = deque()
for i in range(N):
    s.append(str(A.index(i+1)+1))

ans = ' '.join(s)
print(ans)

# Optimized solution
from collections import deque
N = int(eval(input()))
A = [int(i) for i in input().split()]
values = [str(i+1) for i in range(N)]
dic = {key: val for key, val in zip(A, values)}
dic_s = deque(sorted(dic.items()))
s =deque()
for i in range(N):
    s.append(dic_s[i][1])

ans = ' '.join(list(s))
print(ans)
# Original solution
n=int(input())
al=list(map(int,input().split()))

d={}
for i in range(n):
  d[al[i]]=i+1

l=[]
for k,v in sorted(d.items()):
  l.append(v)
  
print(*l,sep=" ")


# Optimized solution
n=int(eval(input()))
al=list(map(int,input().split()))
l=[0 for i in range(n)]
for i in range(n):
    l[al[i]-1]=str(i+1)
print((" ".join(l)))
# Original solution
#coding: UTF-8
N = int(eval(input()))
A = list(map(int, input().split()))
ans = []
for i in range(N):
  ans.append(A.index(i + 1) + 1)
ans = list(map(str, ans))
ans = " ".join(ans)
print(ans)

# Optimized solution
#coding: UTF-8
N = int(eval(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)
# Original solution
eval(input())
li=list(map(int,input().split()))
enu_li=[[i,value] for i,value in enumerate(li,1)]

enu_li=sorted(enu_li,key=lambda x:x[1])

result=[str(value[0]) for value in enu_li]

print((' '.join(result)))

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

mod_li=[[i,num] for i,num in enumerate(li,1)]
result_li=sorted(mod_li, key=lambda x: x[1])

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

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

import math

if N%2==0:
    for i in range(math.ceil(N/2)):
        B+=str(A.index(i+1)+1)+' '
        C+=str(A.index(N//2+i+1)+1)+' '
    print((B+C[0:-1]))
else:
    for i in range(math.ceil(N/2)):
        B+=str(A.index(i+1)+1)+' '
        C+=str(A.index(N//2+i+1)+1)+' '
    print((B+C[2:-1]))    

# Optimized solution
N=int(eval(input()))
A=list(map(int, input().split()))
B=[0]*N
C=''
 
for i in range(N):
    B[A[i]-1]=i+1
 
for i in range(N):
    C+=str(B[i])+' '
 
print((C[0:-1]))
# Original solution
n=int(eval(input()))
l=list(map(int,input().split()))
la=[]
for i in range(1,n+1):
  la.append(l.index(i)+1)
ans=[str(j) for j in la]
ans=" ".join(ans)
print(ans)

# Optimized solution
n=int(eval(input()))
l=list(map(int,input().split()))
la=[0]*n
for i in range(n):
  la[l[i]-1]=i+1
ans=[str(j) for j in la]
ans=" ".join(ans)
print(ans)
# 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 = [None] * 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 = [str(a.index(i + 1) + 1) for i in range(n)]
print((" ".join(ans)))


# Optimized solution
# https://atcoder.jp/contests/abc142/tasks/abc142_c
n = int(eval(input()))
a = list(map(int, input().split()))
#### TLE ####
# ans = [str(a.index(i + 1) + 1) for i in range(n)]
# print(" ".join(ans))

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

print((" ".join(b)))
# Original solution
n = int(input())
a = [(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))]
a.sort()
m = len(a)
for i in range(m):
    print(a[i][1],end="")
    if(i + 1 < m):
        print(" ",end="")
print()


# Optimized solution
n = int(eval(input()))
a = sorted([(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))])
print((" ".join([str(x[1]) for x in a])))
# Original solution
n = int(eval(input()))
a = sorted([(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))])
print((" ".join([str(x[1]) for x in a])))

# Optimized solution
n = int(eval(input()))
print((" ".join([str(x[1]) for x in sorted([(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))])])))
# Original solution
n = int(eval(input()))
print((" ".join([str(x[1]) for x in sorted([(int(a), num) for a, num in zip(input().split(" "), list(range(1,n + 1)))])])))

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

# Optimized solution
print((" ".join([str(x[0]) for x in sorted([(n,int(a)) for n,a in zip(list(range(1,int(eval(input())) + 1)),input().split(" "))],key=lambda x: x[1])])))
# Original solution
if __name__ == '__main__':
    n = int(eval(input()))
    a = [int(i) for i in input().split()]
    ans = {}
    for i in range(n):
        ans[a[i]-1] = i+1
    ans_str =""
    for i in range(n):
        if ans_str =="":
            ans_str = str(ans[i])
        else:
            ans_str = ans_str+" "+str(ans[i])
    print(ans_str)

# Optimized solution
if __name__ == '__main__':
    n = int(eval(input()))
    a = [int(i) for i in input().split()]
    ans = [0]*n
    for i in range(n):
        ans[a[i]-1] = i+1
    ans_list = list(map(str, ans))  # mapで要素すべてを文字列に
    ans_str =' '.join(ans_list)
    print(ans_str)
# Original solution
N = int(eval(input()))
As = [int(x) for x in input().split()]
rs = list(range(1,N+1))
print((" ".join(map(str,[As.index(r)+1 for r in rs]))))

# Optimized solution
N = int(eval(input()))
As = [int(x) for x in input().split()]
rs = list(range(1,N+1))
for i,A in enumerate(As):
    rs[A-1] =i+1

print((" ".join(map(str,rs))))
# Original solution
#142c
N = int(eval(input()))
A_list = list(map(int, input().split()))

#高橋くんは N人の生徒たちのいるクラスの担当教師です。
#生徒たちには 1から Nまでの出席番号が重複なく割り当てられています。
#今日は全ての生徒たちが相異なるタイミングで登校しました。
#高橋くんは、出席番号 iの生徒が登校した時点で、教室に Ai 人の生徒たちがいたことを記録しています(出席番号 iの生徒を含む)。
#記録された情報を元に、生徒たちの登校した順番を復元してください。

#出力 生徒たちの出席番号を登校した順に出力せよ。

#8
#出席番号
#1 2 3 4 5 6 7 8
#登校時の人数
#8 2 7 3 4 5 6 1

#8 2 4 5 6 7 3 1

print((' '.join(map(str, [A_list.index(i)+1 for i in range(1,N+1)]))))

# Optimized solution
#142c
N = int(eval(input()))
A_list = list(map(int, input().split()))

#高橋くんは N人の生徒たちのいるクラスの担当教師です。
#生徒たちには 1から Nまでの出席番号が重複なく割り当てられています。
#今日は全ての生徒たちが相異なるタイミングで登校しました。
#高橋くんは、出席番号 iの生徒が登校した時点で、教室に Ai 人の生徒たちがいたことを記録しています(出席番号 iの生徒を含む)。
#記録された情報を元に、生徒たちの登校した順番を復元してください。

#出力 生徒たちの出席番号を登校した順に出力せよ。

#8
#出席番号
#1 2 3 4 5 6 7 8
#登校時の人数
#8 2 7 3 4 5 6 1

#8 2 4 5 6 7 3 1

index_list = [i for i in range(1,N+1)]
class_dict = dict(list(zip(A_list,index_list)))

#print(' '.join(map(str, [A_list.index(i)+1 for i in range(1,N+1)])))

class_sorted = sorted(list(class_dict.items()),key=lambda x:x[0])
ans = [i[1] for i in class_sorted]
print((' '.join(map(str, ans))))
# Original solution
if __name__ == "__main__":
    list = []
    tmp = []
    sort_list = []
    num = int(eval(input()))
    list = input().split()
    for i,v in enumerate(list):
        tmp.append([int(v),i+1])
    sort_list=sorted(tmp)
    ans = [str(i[1]) for i in sort_list ]
    print((" ".join(ans)))

# Optimized solution
#-*-coding:utf-8-*-
import sys
input=sys.stdin.readline

def main():
    attended_people=[]
    sorted_attended_people=[]
    index_number=[]
    answer=[]
    n = int(eval(input()))
    attended_people=list(map(int,input().split()))
    index_number=[[idx,number] for idx,number in enumerate(attended_people)]
    sorted_attended_people=sorted(index_number,key=lambda x:x[1])
    for idx,data in sorted_attended_people:
        answer.append(str(idx+1))
    print((" ".join(answer)))

if __name__=="__main__":
    main()
# Original solution
N = int(eval(input()))
A = input().split(' ')

t = []
for i in range(N):
    t.append(0)

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

res = ''
for i in range(N):
    res = res + str(t[i]) + ' '

print((res.strip()))


# Optimized solution
N = int(eval(input()))
A = input().split(' ')

t = []
for i in range(N):
    t.append(0)

for i in range(N):
    t[int(A[i]) - 1] = str(i + 1)

print((' '.join(t)))
# Original solution
N = int(eval(input()))
a = input().split()
 
a_list = [int(i) for i in a]

a_list_index = [a_list.index(i+1) + 1 for i in range(N)]

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

# Optimized solution
N = int(eval(input()))
a = input().split()
 
#a_list = [int(i) for i in a]
#a_list_index = [a_list.index(i+1) + 1 for i in range(N)]
#print(' '.join(map(str, a_list_index)))

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