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):
def ji(tup):
  return(tup[1])


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

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

b.sort(key=ji)
for key in range(n):
  print(b[key][0],end=" ")

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

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

l = [0]*n
snum = 0

for i in A:
    snum += 1
    l[i-1] = snum

for j in l:
    print(j,end=" ")

Solution (Python):
stu = 0
def g(val):
    global stu
    stu += 1
    return [stu, int(val)]

n = int(input())
a = list(map(g, input().split()))
a.sort(key=lambda x: x[1])

op = str(a[0][0])
for i in range(1,n):
    op += " " + str(a[i][0])
print(op)

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

B = []
for i in range(n):
    B.append((i,A[i]))
B.sort(key=lambda x:x[1])
for i in B:
    print(i[0]+1, end=" ")

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

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

Solution (Python):
N = int(input())
Mylist = list(map(int, input().split()))
ANSlist = [0 for i in range(N)]
for j in range(N):
    ANSlist[Mylist[j]-1] = j + 1
ANSlist=[str(a) for a in ANSlist]
ANS = ' '.join(ANSlist)
print(ANS)

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

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

for i in range(N):
    print(S[i], end=" ") 
print('')

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
d=[None]*n
for x,i in enumerate(a):
    d[i-1]=x+1
for i in d:
    print(i,end=" ")

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) 

print(*ans)

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

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

print(*ans)

Solution (Python):
N = int(input())
A = [int(x) for x in input().split()]
B=[0]*N
for i in range(N):
  B[A[i]-1] += i+1
print(*B)

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

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

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

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
print(*ans)

Solution (Python):
import numpy as np
n=int(input())
a=[list(map(int,input().split()))]
b=[[i+1 for i in range(n)]]
a=np.array(a)
b=np.array(b)
c = np.concatenate([a,b])
d=np.argsort(c[0, :])
d=[d[i]+1 for i in range(n)]
print(' '.join(map(str, d)))

Solution (Python):
def abc142_c2():    
    n = int(input())
    a = list(map(int, input().split()))
    
    ans = [0] * n

    
    for val, num in enumerate(a, 1):
        ans[num - 1] = val
    
    print(*ans)
if __name__ ==  '__main__':
    abc142_c2()

Solution (Python):
import collections

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

b = collections.OrderedDict()
for i in range(len(a)):
    b[i + 1] = a[i]

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

for i, j in c:
    print(i, end=' ')

Solution (Python):
n = int(input())
ar = [int(x) for x in input().split()]

res = [0 for i in range(n)]

for i in range(1, n+1):
  res[ar[i-1]-1] = i
for i in res:
  print(str(i), end=" ")

Solution (Python):
N = int(input())
A = [int(i) for i in input().split()]
order = [None] * N
for i in range(N):
    order[A[i]-1] = i+1

for o in order:
    print(o, end=' ')

Solution (Python):
import numpy as np
n = int(input())
a = list(map(int,input().split()))
line = np.ndarray((n,2),np.int64)
for i in range(n):
  line[i][0] = i + 1
  line[i][1] = a[i]

s = sorted(line,key=lambda x:x[1])
for i in range(n):
  print(s[i][0])

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

Solution (Python):
from collections import UserList


def main():
    _ = input()
    A = Array(input().split(" ")).map(int)
    ans = A.with_index().sort(lambda x: x[1]).map(lambda x: x[0] + 1).join_to_str(" ")
    print(ans)


class Array(UserList):
    def __init__(self, iterable):
        self.data = iterable

    def map(self, f):
        return Array([f(x) for x in self.data])

    def join_to_str(self, sep):
        return sep.join(self.map(str))

    def filter(self, f):
        return Array([x for x in self.data if f(x)])

    def with_index(self):
        return Array([(i, x) for i, x in enumerate(self.data)])

    def sort(self, key):
        return Array(sorted(self.data, key=key))

    def sum(self):
        return sum(self.data)

    def min(self):
        return min(self.data)

    def max(self):
        return max(self.data)

    def fold_left(self, f, init):
        ret = init
        for x in self.data:
            ret = f(ret, x)
        return ret

    def _scan_left(self, f, init):
        ret = init
        for x in self.data:
            ret = f(ret, x)
            yield ret

    def scan_left(self, f, init):
        return Array(list(self._scan_left(f, init)))

    def lower_bound(self, x):
        """x以上になる最小のindex"""
        low = 0
        high = len(self)
        while low < high:
            mid = (low + high) // 2
            if self[mid] < x:
                low = mid + 1
            else:
                high = mid
        return low

    def upper_bound(self, x):
        """xより大きくなる最小のindex"""
        low = 0
        high = len(self)
        while low < high:
            mid = (low + high) // 2
            if self[mid] <= x:
                low = mid + 1
            else:
                high = mid
        return low

    def _distinct(self):
        dic = {}
        for x in self.data:
            if dic.get(x):
                continue
            dic[x] = True
            yield x

    def distinct(self):
        return Array(list(self._distinct()))


if __name__ == "__main__":
    main()

Solution (Python):
from collections import UserList


def main():
    _ = input()
    A = Array(input().split(" ")).map(int)
    ans = A.with_index().sort(lambda x: x[1]).map(lambda x: x[0] + 1).join_to_str(" ")
    print(ans)


class Array(UserList):
    def __init__(self, iterable):
        self.data = iterable

    def map(self, f):
        return Array([f(x) for x in self.data])

    def join_to_str(self, sep):
        return sep.join(self.map(str))

    def filter(self, f):
        return Array([x for x in self.data if f(x)])

    def with_index(self):
        return Array([(i, x) for i, x in enumerate(self.data)])

    def sort(self, key):
        return Array(sorted(self.data, key=key))

    def sum(self):
        return sum(self.data)

    def min(self):
        return min(self.data)

    def max(self):
        return max(self.data)

    def fold_left(self, f, init):
        ret = init
        for x in self.data:
            ret = f(ret, x)
        return ret

    def _scan_left(self, f, init):
        ret = init
        for x in self.data:
            ret = f(ret, x)
            yield ret

    def scan_left(self, f, init):
        return Array(list(self._scan_left(f, init)))

    def lower_bound(self, x):
        """x以上になる最小のindex"""
        low = 0
        high = len(self)
        while low < high:
            mid = (low + high) // 2
            if self[mid] < x:
                low = mid + 1
            else:
                high = mid
        return low

    def upper_bound(self, x):
        """xより大きくなる最小のindex"""
        low = 0
        high = len(self)
        while low < high:
            mid = (low + high) // 2
            if self[mid] <= x:
                low = mid + 1
            else:
                high = mid
        return low

    def _distinct(self):
        dic = {}
        for x in self.data:
            if dic.get(x):
                continue
            dic[x] = True
            yield x

    def distinct(self):
        return Array(list(self._distinct()))


if __name__ == "__main__":
    main()

Solution (Python):
from operator import itemgetter
n = int(input())
L = list(map(int, input().split()))
M = []
for i in range(n):
  M.append([i, L[i]])
  
M.sort(key=itemgetter(1))
for i in range(n):
  print(M[i][0]+1, end=' ')

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

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

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

main()

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

for i in range(N):
    dic.setdefault(a[i], i+1)
    
dic = sorted(dic.items(), key=lambda x:x[0])

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

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

result = np.argsort(A) + 1

print(*result)

Solution (Python):

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

b = [0]*n

for i , val in enumerate(a):
    b[val-1] = i+1
print(*b)

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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
import numpy as np
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

n = inp()


L = inpl()


Lsort = sorted(L)


zL = list(zip(L, Lsort))

zL.sort(key = lambda x: x[0])
ansL = [_[1] for _ in zL] 
print(' '.join(map(str, ansL)))

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

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

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

print(" ".join(map(str, order[1:])))

Solution (Python):

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

ans = [ 0 for _ in range(n)]
for i, aa in enumerate(a):
    aa -= 1
    ans[aa] = i+1

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

Solution (Python):
n = int(input())
l = [int(i) for i in input().split()]
l2 = []
l3 = []
for i in range(n):
    l2.append([l[i],i+1])
l2.sort()
for i in range(n):
    l3.append(l2[i][1])
print(' '.join(map(str,l3)))

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

L = {}

for i in range(n):
    L[i] = l[i]

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

for j in sort_L:
    print(j[0]+1, end=" ")

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

L = [0]*n

for i, order in enumerate(l,1):
    L[order-1] = i

print(*L)

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

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

B=[[A[i],i] for i in range(N)]
B.sort()

for i in B:
  print((i[1]+1))

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

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

for i in range(len(B)):
  print(str(B[i]), end="")
  if i == len(B)-1:
    break
  print(" ", end = "")
print()

Solution (Python):

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

ans = [ 0 for _ in range(n)]
for i, aa in enumerate(a):
    aa -= 1
    ans[aa] = i+1

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

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

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

if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np

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

print(' '.join(map(str, (np.argsort(A)+1).tolist())))

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

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

Solution (Python):
import numpy as np
N=int(input())
A=list(map(int,input().split(' ')))

res=np.argsort(A)+1
print(' '.join([str(x) for x in res]))

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

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

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

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

Solution (Python):
_ = input()
l = list(map(int,input().split()))
dic = {l[i]:i for i in range(len(l))}
l = sorted(l)
ans = [str(dic[i] + 1) for i in l]
print(" ".join(ans))

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

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

print(' '.join(B))

Solution (Python):
def calculate(n, arr):
    result = [0] * len(arr)

    for index, value in enumerate(arr):
        result[value - 1] = str(index + 1)

    return result


N = int(input())
S = input().split(' ')
arr = list(map(int, list(S)))
result = calculate(N, arr)


print(' '.join(result))

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

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
temp = sorted(range(len(a)), key=lambda k: a[k])
for i in range(len(temp)):
  print(temp[i]+1)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = [0] * n

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

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

a = list(map(int,input().split()))
         
dic = {}

for i in range(1, n+1):
  dic[a[i-1]] = i
  
for s in sorted(dic.keys()):
  print(dic[s], end=' ')
  
print()

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

ans = sorted(range(len(A)), key=A.__getitem__)
ans = [a+1 for a in ans]
print(*ans)

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

Solution (Python):
N = int(input())
ans = [None] * N

for idx, a in enumerate(list(map(int, input().split()))):
    ans[a-1] = idx+1
    
print(' '.join(map(str, ans)))

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

b = []


for i,x in enumerate(a):
    b.append([x,i+1])

b = sorted(b, key=lambda x:x[0])

c = [str(x[1]) for x in b]

print(' '.join(c))

Solution (Python):
n = int(input())
x = [int(i) for i in input().split()]
y = []
for i in range(len(x)):
	y.append([x[i], i+1])

z = sorted(y)
for i in z:
	print(i[1], end = ' ')

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

order = [0] * N
for i in range(N):
    order[int(A[i]) - 1] = i + 1
print(" ".join([str(j) for j in order]))

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

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

B = [[A[i], i+1] for i in range(n)]

B.sort()

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

Solution (Python):
N = int(input())
let=input().split()

list=list(range(N))
for i in range(N):
    list[int(let[i])-1]=i+1

for num in list:print(num)

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

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

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

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

b = list(enumerate(a))

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

print(" ".join(map(lambda x: str(x[0]+1), c)))

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

A_index = []
for i in range(N):
    A_index.append([A[i], i])
A_index.sort()

ans = [x[1]+1 for x in A_index]
print(' '.join(map(str, ans)))

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
a = {v: i+1 for i, v in enumerate(a)}
ans = [a[i] for i in range(1, n+1)]
print(*ans)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
idx = {j: i for i, j in zip(range(1, n + 1), a)}
ans = []
for i in range(1, n+1):
    ans.append(idx[i])
print(*ans)

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

memo.sort(key=lambda x: x[1])
for i, a in memo:
    print(i, end=' ')

Solution (Python):
n = int(input())
a = [i for i in map(int, input().split())]
stu = [{'no' : i, 'arv':a[i]} for i in range(n)]

stu.sort(key=lambda x: x['arv'])

res = []
for i in stu:
    res.append(i['no'] + 1)

for i in res:
    print(i, end=" ")

Solution (Python):
n = int(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)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = [None] * N
for i, j in enumerate(A):
    ans[j - 1] = str(i + 1)
print(*ans)

Solution (Python):
N = int(input())
A = list(map(int, input().split()))
ans = [None for _ in range(N)]
for i, j in enumerate(A):
    ans[j-1] = str(i + 1)
print(" ".join(ans))

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

Solution (Python):
n = int(input())
A = input().split()
for i in range(n):
  A[i] = [int(A[i]),i+1]
A = sorted(A, key=lambda x:x[0])
for a in A[:]:
  print(a[1],end=" ")

Solution (Python):
def main():
    n  = int(input())
    students = list(map(int,input().split()))
    number = [i for i in range(1,n+1)]
    students_number = []
    for i in range(n):
        students_number.append([students[i]] + [number[i]])
    sorted_students_number = sorted(students_number,key = lambda x:x[0])
    ans = [i[1] for i in sorted_students_number]
    print(*ans)

if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = [0]*n

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

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

Solution (Python):
n = int(input())
a  = list(map(int,input().split()))
b = {}
cnt = 1;
for i in a:
    b[i] = cnt
    cnt+=1
a.sort()
for i in a:
    print(b[i], end=" ")

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

Solution (Python):
import sys
input = sys.stdin.readline
import numpy as np
def print_ans(input_line):
    """Test Case
    >>> print_ans("2 3 1")
    3 1 2
    >>> print_ans("1 2 3 4 5")
    1 2 3 4 5
    >>> print_ans("8 2 7 3 4 5 6 1")
    8 2 4 5 6 7 3 1
    """
    arr = np.array(list(map(int,input_line.split())))
    arr_sort = np.argsort(arr) + 1
    arr_str = list(map(str,arr_sort.tolist()))
    print(" ".join(arr_str))

if __name__ == '__main__':
    N = int(input())
    input_line = input()
    print_ans(input_line)

Solution (Python):
num = int(input())
orders = list(map(int,input().split()))

ans_li = [0 for i in range(num)]

for i in range(num):
    order = orders[i]
    ans_li[order - 1] = i + 1

print(*ans_li)

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

L=[0]*n

for i in range(n):
  s = A[i]
  L[s-1] = i+1

print(*L)

Solution (Python):
import numpy as np

N = int(input())

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

ans = np.argsort(A_list) + 1


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

Solution (Python):
n=int(input())
L=list(map(int,(input()).split()))
L=list(map(lambda x: x-1, L))

NL=[0]*n
for i in range(n):
      NL[L[i]]=i+1
print(*NL)

Solution (Python):
import bisect

n=int(input())
L=list(map(int,(input()).split()))
L=list(map(lambda x: x-1, L))

NL=[0]*n
for i in range(n):
      NL[L[i]]=i+1
print(*NL)

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
    
print(' '.join(map(str,res)))

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

res = sorted(range(1, n + 1), key=lambda k:a_s[k - 1])
for r in res:
	print(r, end=" ")

Solution (Python):
size = int(input())
personList = [int(x) for x in input().split()]
result = list(range(size))
for i, order in enumerate(personList):
  result[order - 1] = i + 1
print(' '.join(map(str, result)))

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

B = [(a, i + 1) for i, a in enumerate(A)]
B.sort()

print(*[b[1] for b in B])

Solution (Python):
def main():

    N = int(input())
    A = list(int(x) for x in input().split())
    ans = [0] * N

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

    print(' '.join(map(str, ans)))
    
if __name__ == '__main__':
    main()

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

s = [0] * n
for i, m in enumerate(a, start=1):
    s[m - 1] = i

b = " ".join(list(map(str, s)))
print(b)

Solution (Python):
n=int(input())
a=sorted([[i,int(j)] for i,j in enumerate(input().split())],key=lambda x:x[1])
ans=[]
for i in range(n):
    ans+=[str(a[i][0]+1)]
print(*ans,sep=' ')

Solution (Python):

from collections import defaultdict
N = int(input())
lst = [int(i) for i in input().split()]

d = defaultdict(int)
for i, v in enumerate(lst, start=1):
    d[i] = v

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

ans = []
for k, v in d2:
    ans.append(k)
print(*ans)

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

Solution (Python):
import numpy as np

if __name__ == "__main__":
    n = int(input())
    a = list(map(int, input().split(" ")))
    a = np.array(a)

    aSortedIndex = np.argsort(a)

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

Solution (Python):
n=int(input())
a=list(map(int,input().split()))
s=[0]*n
for i,m in enumerate(a):
  s[m-1]=i+1
b=map(str,s)
print(' '.join(b))

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

d = {p:i for i, p in enumerate(a, start=1)}
s = [str(i[1]) for i in sorted(d.items())]
print(' '.join(s))

Solution (Python):



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

ansl = [0 for _ in range(n)]
for idx, a in enumerate(al):
    ansl[a-1] = idx

for i in ansl:
    print(i+1)

Solution (Python):
input()
a=list(map(int,input().split()))
print(' '.join([str(i[0]) for i in sorted([[i+1,a[i]]for i in range(0,len(a))],key=lambda x: x[1])]))

Solution (Python):
input()
a=list(map(int,input().split()))
print(' '.join([str(i[0]) for i in sorted([[i+1,a[i]]for i in range(0,len(a))],key=lambda x: x[1])]))

Solution (Python):
n = int(input())
a = map(int, input().split())
ans = [0]*n
for i, ai in enumerate(a):
    ans[ai-1] = i+1
print(*ans)

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

l_sorted = [0] * N

for i in range(N):
    l_sorted[l[i] - 1] = i + 1



for i in range (N):
    print(l_sorted[i])

Solution (Python):
n = int(input())
ai = list(map(int,input().split()))
ansss = [0]*n

for i in range (0,n):
    ansss[ai[i]-1]  = i+1

print(*ansss)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = [0]*n

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

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

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

print(*c)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
ans = [0]*n

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

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

Solution (Python):
import unittest


class TestC(unittest.TestCase):
    def test_1(self):
        self.assertEqual(think([2, 3, 1]), [3, 1, 2])

    def test_2(self):
        self.assertEqual(think([1, 2, 3, 4, 5]), [1, 2, 3, 4, 5])

    def test_3(self):
        self.assertEqual(think([8, 2, 7, 3, 4, 5, 6, 1]), [8, 2, 4, 5, 6, 7, 3, 1])


def solve():
    a = read()
    result = think(a)
    write(result)


def read():
    n = read_int(1)[0]
    return read_int(n)


def read_int(n):
    return list(map(lambda x: int(x), read_line().split(' ')))[:n]


def read_float(n):
    return list(map(lambda x: float(x), read_line().split(' ')))[:n]


def read_line(n=0):
    if n == 0:
        return input().rstrip()
    else:
        return input().rstrip()[:n]


def think(a):
    list_of_index_and_a = []
    for index, e in enumerate(a):
        list_of_index_and_a.append((index + 1, e))

    list_of_index_and_a.sort(key=lambda x: x[1])
    return [x[0] for x in list_of_index_and_a]


def write(result):
    print(' '.join(list(map(lambda x: str(x), result))))


if __name__ == '__main__':
    
    solve()

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

print(' '.join(map(str, result[1::])))

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


A = [[i, int(a)] for (i, a) in zip(range(1, N+1), input().split())]


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

print(' '.join(map(str, [row[0] for row in A])))

Solution (Python):
li = lambda: list(map(int,input().split()))

n = int(input())
a = li()

aa = [(i+1,a[i]) for i in range(n)]
aa.sort(key=lambda x: x[1])
a = [aaa[0] for aaa in aa]
ans = ''
for aa in a:
    ans += str(aa)
    ans += ' '
print(ans[:-1])

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

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

timelist =list(map(int,input().split()))
numberList = ["."]*n
for i in range(len(timelist)):
    numberList[timelist[i]-1]=str(i+1)
for a in numberList:
    print(a,end=" ")

Solution (Python):
n=int(input())
A=list(map(int,input().split()))
L=[""]*n
for i,a in enumerate(A):
  L[a-1]=str(i+1)
print(' '.join(L))

Solution (Python):
N = int(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))

Solution (Python):
n = int(input())
L = list(map(int,input().split()))
S = []
K = []
for i in range(n):
  S.append([L[i],i+1])
S.sort()
for i in range(n):
  K.append(S[i][1])
print(' '.join(map(str,K)))

Solution (Python):
N = int(input())
order = list(map(int,input().split()))
array = []
for i in range(N):
  array.append(0)

for i,o in enumerate(order):
  array[o-1] = i + 1

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

Solution (Python):
n = int(input())
junban = [None for _ in range(n)]
a_list = list(map(int, input().split()))
for i in range(n):
  junban[a_list[i]-1] = str(i+1)
print(" ".join(junban))

Solution (Python):
from sys import stdin
n = int(stdin.readline().rstrip())
a = [int(x) for x in stdin.readline().rstrip().split()]
b = [0] * n
for i in range(n):
    b[a[i] - 1] = i + 1
b = [str(x) for x in b]
b = ' '.join(b)
print(b)

Solution (Python):
n = int(input())
a = list(map(int, input().split()))
b = [0]*n
for index, item in enumerate(a, 1):
    b[item-1] = index
for i in b:
    print(i,end=' ')

Solution (Python):
from sys import stdin

input = stdin.readline


def p_a():
    n = int(input())
    print(((n + 1) // 2) / n)


def p_b():
    n, k = map(int, input().split())
    h = list(map(int, input().split()))

    print(sum(map(lambda x: x >= k, h)))


def p_c():
    n = int(input())
    k = list(map(int, input().split()))

    print(*[i[0] for i in sorted(enumerate(k, start=1), key=lambda x: x[1])])


if __name__ == '__main__':
    p_c()

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

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

Solution (Python):
n,*a= map(int,open(0).read().split())
"""
b=[]

for i in range(1,n+1):
    b.append(a.index(i)+1)
"""
b=[[a[i],i+1] for i in range(n)]
b.sort(key=lambda x: x[0])
for bb in b:
    print(bb[1],end =" ")
print("")

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

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

Solution (Python):
raw_input()
v = sorted((int(e), k) for k, e in enumerate(raw_input().split(), 1))
_, w = zip(*v)
print ' '.join(map(str, w))

Solution (Python):
n = int(input())
nums = map(int,input().split())
dics = {}
result = []
i = 1

for num in nums:
  dics[num] = i 
  i += 1

for x in range(1,n+1):
  result.append(dics[x])
  
for p in result:
  print(p,end=" ")

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

Solution (Python):
N=int(input())
L=list(map(int,input().split()))
D=sorted(dict([(i,L[i]) for i in range(N)]).items(),key=lambda x:x[1])
for k in range(N):
  print(D[k][0]+1,end=" ")

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

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

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

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

ans = []
for t in sorted_dict:
    ans.append(t[0])
print(' '.join(map(str, ans)))

Solution (Python):
n = int(input())
a=[]

b = list(map(int, input().split()))
for i in range(n):
    a+=[[i+1, b[i]] ]
    
    
import operator as op
a.sort(key = op.itemgetter(1))

x=""
for i in range(n):
    x+=str(a[i][0])
    if i!=n-1:
        x+=" "

print(x)