CodeEff/ECCO huggingface dataset:
# Original solution
if __name__ == "__main__":
    N = int(eval(input()))
    As = list(map(int, input().split(" ")))

    bosses = []
    for n in range(1, N+1):
        bosses.append(As.count(n))
    
    print(("\n".join(map(str, bosses))))

# Optimized solution
if __name__ == "__main__":
    N = int(eval(input()))
    As = list(map(int, input().split(" ")))

    bosses = [0]*N
    for a in As:
        bosses[a-1] = bosses[a-1] + 1
    
    print(("\n".join(map(str, bosses))))
# Original solution
a = list(map(int, input().split()))
b = list(map(int, input().split()))
for i in range(1, a[0]+1):
  print((b.count(i)))

# Optimized solution
n,*a=map(int,open(0).read().split())
b=[0]*n
for i in a:
  b[i-1]+=1
print(*b, sep="\n")
# Original solution
from collections import Counter

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

c=Counter(a)

for i in range(1,n+1):
  print((c[i]))

# Optimized solution
from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))

n=int(eval(input()))
a=lnii()

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

for i in a:
  i-=1
  ans[i]+=1

for i in ans:
  print(i)
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
b=0

for i in range(1,n+1):
   b=a.count(i)
   print(b)

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

for i in range(0,len(a)):
   b[a[i]-1]+=1
[print(i) for i in b]
# Original solution
a = int(eval(input()))
i = list(map(int, input().split()))
for num in range(a):
  sum = 0
  for num2 in range(len(i)):
    if i[num2] == num + 1:
      sum += 1
  print(sum)      

# Optimized solution
a = int(eval(input()))
i = list(map(int, input().split()))
dict = {}
for num in range(a):
  dict[num] = 0

for num2 in range(len(i)):
  dict[i[num2] - 1] += 1

for num in range(a):
  print((dict[num]))
# Original solution

n = int(eval(input()))
a = list(map(int,input().split()))
t = [0]*(len(a)+1)

for i in range(len(a)+1):
    t[i] = a.count(i+1)

for i in range(len(t)):
    print((t[i]))


# Optimized solution

n = int(eval(input()))
a = list(map(int,input().split()))
t = [0]*(len(a)+1)

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

for i in range(len(t)):
    print((t[i]))
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))
B=set(A)
for i in range(1,N+1):
  if i not in B:
    print((0))
  else:
    print((A.count(i)))


# Optimized solution
N=int(eval(input()))
A=list(map(int,input().split()))
B=[0]*(N+1)
for i in A:
  B[i]+=1
for j in range(1,N+1):
  print((B[j]))
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(1,N+1):
    print((A.count(i)))


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

for i in A:
    L[i] += 1

for i in range(1,len(L)):
    print((L[i]))
# Original solution
N=int(eval(input()))
A=list(map(int, input().split()))

for i in range(N):
    print((A.count(i+1)))

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

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

for i in range(N):
    print((ans[i]))
# Original solution
n= int(input())
l = list(map(int, input().split()))
print(*[l.count(i) for i in range(1,n+1)],sep='\n')


# Optimized solution
n = int(input())
a = list(map(int, input().split()))
ans = [0]*n
for i, a in enumerate(a):
     ans[a-1] += 1
print(*ans, sep="\n")
# Original solution
from collections import Counter
N = int(eval(input()))
List = list(map(int,input().split()))
C = Counter(List)

for i in range(1,N):
  if i in list(C.keys()):
    print((C[i]))
  else:
    print((0))
print((0))

# Optimized solution
N = int(eval(input()))
ls = list(map(int,input().split()))
cnt = [0] * (N+1)

for i in range(N-1):
    cnt[ls[i]] += 1
    
for i in range(1,N+1):
    print((cnt[i]))
# Original solution
n=int(eval(input()))
A=list(map(int,input().split()))
R=[0]*n
for a in A:
  R[a-1]+=1
for r in R:
  print(r)

# Optimized solution
#!/usr/bin python3
# -*- coding: utf-8 -*-

import sys
input = sys.stdin.readline

def main():
    N = int(eval(input()))
    A = list(map(int, input().split()))
    ret = [0]*N
    for a in A:
        ret[a-1]+=1
    print(('\n'.join(map(str, ret))))

if __name__ == '__main__':
    main()
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))
i = 0
while i < N:
    num = 0
    for j in A:
        if j == i + 1:
            num += 1
    i += 1
    print(num)    



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

for i in range(N):
    print((A.count(i+1)))


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

for i in A:
    cnt[i-1] += 1

for i in range(N-1):
    print((cnt[i]))

print("0")
# Original solution
N = int(eval(input()))
from collections import Counter as C
l = dict(C((int(x) for x in input().split())))
for x in range(1,N+1):
    print((l.get(x,0)))

# Optimized solution
n = int(eval(input()))
al = [int(x) - 1 for x in input().split()]
a = []
count = 0
for _ in [0] * n:
    a.append(0)
for x in al:
    a[x] += 1
    count += 1
for x in a:
    print(x)
# Original solution
N=int(eval(input()))
A=list(map(int,input().split()))

for i in range(1,N+1):
    print((A.count(i)))

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

for i in A:
    B[i-1]+=1

for i in B:
    print(i)
# Original solution

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

buka = []


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

    buka.append(b)
    
# 出力
for i in range(N):
    print((buka[i]))



# Optimized solution

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

buka = [0] * N

for i in range(N-1):
    buka[A[i]-1] += 1
    
# 出力
for i in range(N):
    print((buka[i]))
# Original solution
n = int(eval(input()))

line = list(map(int, input().strip().split(" ")))

for i in range(1, n + 1):
    print((line.count(i)))


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

line = list(map(int, input().strip().split(" ")))

ans = [0 for s in range(n)]

for i in line:
    ans[i - 1] += 1

for i in range(n):
    print((ans[i]))
# Original solution
n = int(eval(input()))
li_a = list(map(int, input().split()))

set_a = set(li_a)

for i in range(1, n + 1):
    if i in set_a:
        print((li_a.count(i)))
    else:
        print((0))


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

dic = {}
for a in li_a:
    dic[a] = dic.get(a, 0) + 1

for i in range(1, n + 1):
    print((dic.get(i, 0)))
# Original solution
# 5 
# 1 1 2 2

# 5人の部下
# 社員番号 2の社員の直属の上司の社員番号が 1, 社員番号 3の社員の直属の上司の社員番号が 1, 社員番号 4の社員の直属の上司の社員番号が 2, 社員番号 5の社員の直属の上司の社員番号が 2,
 

N = int(eval(input()))

AnStr = input().split(' ')
zyosiList = []
for v in AnStr:
  zyosiList.append(int(v))

for i in range(1, N + 1):
  print((zyosiList.count(i)))

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

AnStr = input().split(' ')
zyosiList = []
a = {}
for v in AnStr:
  zyosiList.append(int(v))
  if v in a:
    a[v] += 1
  else:
    a[v] = 0

for i in range(1, N + 1):
  if str(i) in a:
    print((a[str(i)]+1))
  else:
    print((0))
# Original solution
# coding: utf-8
# Your code here!
import sys
readline = sys.stdin.readline
read = sys.stdin.read
 

# n,m = map(int,input().split())

# a = list(map(int, input().split()))  # n個の文字列がリストに格納される

N = int(eval(input()))

A = list(map(int, input().split()))  # n個の文字列がリストに格納される

for i in range(N-1):
    print((A.count(i+1)))
    while i+1 in A:
        A.remove(i+1)

print('0')

# Optimized solution
N = int(input())

A = list(map(int, input().split()))  # n個の文字列がリストに格納される

ans = [0] * N

for a in A:
    ans[a-1] += 1

print(*ans,sep='\n')
# Original solution
from collections import Counter

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

n=int(eval(input()))
a=LI()
c=Counter(a)

for i in range(1,n+1):
    ans=c[i]
    print(ans)



# Optimized solution
from collections import*
n,*a=list(map(int,open(0).read().split()));c=Counter(a)
for i in range(n):print((c[i+1]))
# Original solution
from collections import*
n,*a=list(map(int,open(0).read().split()));c=Counter(a)
for i in range(n):print((c[i+1]))

# Optimized solution
n,*a=list(map(int,open(0).read().split()));c=[0]*n
for q in a:c[q-1]+=1
for d in c:print(d)
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
for i in range(n-1):
    j=i
    k=0
    while j<n-1:
        if i+1==a[j]:
            k=k+1
        j=j+1

    print(k)
print((0))


# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
 
jyoshi=[0]*n
for i in range(n-1):
  jyo=a[i]
  jyoshi[jyo-1]=jyoshi[jyo-1]+1
  
for k in jyoshi:
  print(k)
# Original solution
n=int(eval(input()))
l=list(map(int,input().split()))
from collections import *
c=Counter(l)
for i in range(n): print((c[i+1]))

# Optimized solution
n=int(eval(input()))
from collections import *
c=Counter(list(map(int,input().split())))
for i in range(n): print((c[i+1]))
# Original solution
N = int(eval(input()))
A = [int(x) for x in input().split()]
for i in range(N):
    n = A.count(i+1)
    print(n)
    if i+1 in A:
        A.remove(i+1)

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

for j in range(N):
    print((B[j]))
# Original solution
import sys

n = int(eval(input()))
A = list(map(int, sys.stdin.readline().split()))

ans = [0] * n

for i in A:
    ans[i-1] += 1

for j in ans:
    print(j)

# Optimized solution
import sys

n = int(eval(input()))
A = list(map(int, sys.stdin.readline().split()))

ans = [0] * n

for i in A:
    ans[i-1] += 1

print(('\n'.join(map(str, ans))))
# Original solution
N=int(eval(input()))
A_r=list(input().split())
A=[int(x) for x in A_r]
for i in range(N):
    print((len([j for j,x in enumerate(A) if x==i+1])))
    

# Optimized solution
N=int(eval(input()))
A_r=list(input().split())
A=[int(x) for x in A_r]
B=[0 for i in range(N)]

for i in range(len(A)):
    B[A[i]-1]+=1
for i in range(len(B)):
    print((B[i]))
# Original solution
N = int(eval(input()))
A = list(map(int, input().split()))

for i in range(1, N+1):
    print((A.count(i)))

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

l = [0]*N

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

print(*l, sep="\n")
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))

for i in range(1, n+1):
    cnt = 0
    for j in a:
        if i == j:
            cnt += 1
    print(cnt)


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

cnt = {}
for i in a:
    cnt.setdefault(i, 0)
    cnt[i] += 1

for i in range(1, n+1):
    cnt.setdefault(i, 0)
    print((cnt[i]))
# Original solution
N = int(eval(input()))
arr = list(map(int, input().split()))

for i in range(1,N+1,1):
    print((arr.count(i)))

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

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

for i in range(len(ans)):
    print((ans[i]))
# Original solution
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from collections import Counter


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

    for i in range(N):
        print((Counter(A)[i + 1]))


if __name__ == "__main__":
    main()


# Optimized solution
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from collections import Counter


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

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


if __name__ == "__main__":
    main()
# Original solution
社員数 = int(eval(input()))

上司 = list(map(int, input().split(' ')))

for 社員番号 in range(1, 社員数+1):
    print((上司.count(社員番号)))


# Optimized solution
num_employee = int(eval(input()))
num_subordinate = [0] * num_employee

for boss in map(int, input().split(' ')):
    num_subordinate[boss-1] += 1

print(('\n'.join(map(str, num_subordinate))))
# Original solution
社員数 = int(input())
部下数 = [0] * 社員数

for 上司 in map(int, input().split(' ')):
    部下数[上司-1] += 1

[print(部下) for 部下 in 部下数]


# Optimized solution
社員数 = int(eval(input()))
部下数 = [0] * 社員数

for 上司 in input().split(' '):
    部下数[int(上司)-1] += 1

print(('\n'.join(map(str, 部下数))))
# Original solution
社員数 = int(eval(input()))
部下数 = [0] * 社員数

for 上司 in input().split(' '):
    部下数[int(上司)-1] += 1

print(('\n'.join(map(str, 部下数))))


# Optimized solution
a = int(eval(input()))
b = [0] * a

for c in map(int, input().split()):
    b[c-1] += 1

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

for i in range(n):
    print((a.count(i + 1)))


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

ans = [0]* n

for i in a:
    ans[i - 1] += 1
    
for i in range(n):
    print((ans[i]))
# Original solution
n=int(eval(input()))
a=[int(i) for i in input().split()]

for i in range(1,n+1):
    print((a.count(i)))

# Optimized solution
n=int(eval(input()))
a=[int(i) for i in input().split()]
b={i:0 for i in range(1,n+1)}

for i in a:
    b[i]+=1

for i in list(b.values()):
    print(i)
# Original solution
N = int(eval(input()))
boss = input().split(" ")
for i in range(1,N+1):
  print((boss.count(str(i))))
 	

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

ans = [0] * (N+1)

for i in range(1, N+1):
    ans[i] = A.count(i)

for a in ans[1:]:
    print(a)

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

ans = [0] * (N+1)

for a in A:
    ans[a] += 1

for a in ans[1:]:
    print(a)
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))

for i in range(1,N+1):
    print((A.count(i)))

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

for i in A:
    ans[i-1] += 1

for j in ans:
    print(j)
# Original solution
n = int(eval(input()))
List = list(map(int, input().split(" ")))
a = 1
for i in range(n):
    m = List.count(a)
    a += 1
    print(m)

# Optimized solution
N = int(eval(input()))
List = list(map(int,input().split()))
List2 = [0]*N
for i in range(N-1):
    List2[List[i-1]-1] += 1 
for j in List2:
    print(j)
# Original solution
def main():
    N = int(eval(input()))
    A = list(map(int, input().split()))
    for i in range(N):
        print((A.count(i+1)))
main()

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

for bukaninzu in bukaninzu_list:    
    print(bukaninzu)
# Original solution
n = int(eval(input()))
a = [0]
a += list(map(int,input().split()))
b = [0]*n
for i in range(n):
    print((a.count(i+1)))


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

for i in range(n):
    print((ai.count(i+1)))

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

ans = [0]*n
for i in range(len(ai)):
    ans[ai[i]-1] += 1
for i in range(len(ans)):
    print((ans[i]))
# Original solution
from collections import Counter
n = int(eval(input()))
Al = list(input().split())
count = Counter(Al)
for i in range(n):
    if str(i + 1) in Al:
        print((count[str(i+1)]))
    else:
        print((0))

# Optimized solution
from collections import Counter
n = int(eval(input()))
Al = list(input().split())
cdict = Counter(Al)
for i in range(n):
    print((cdict[str(i+1)]))
# Original solution
N = int(eval(input()))
d = list(map(int, input().split()))
for j in range(1, N+1):
    count = 0
    for i in range(len(d)):
        if j == d[i]:
            count += 1
    print(count)

# Optimized solution
N = int(eval(input()))
d = list(map(int, input().split()))
p = [0] * N
for i in range(N - 1):
    p[d[i] - 1] += 1
for i in range(N):
    print((p[i]))
# Original solution
from collections import Counter
n = int(eval(input()))
a = Counter(list(map(int, input().split())))

for i in range(n):
  print((a[i+1]))

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

s = [0]*n
for i in a:
  s[i-1] += 1
  
for i in s:
  print(i)
# Original solution
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))

count = Counter(a)
for i in range(n):
  if i+1 in count:
    print((count[i+1]))
  else:
    print((0))

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

l = [0]*n
for i in a: l[i-1] += 1
print(*l, sep='\n')
# Original solution
from collections import defaultdict
N = int(eval(input()))
A = list(map(int,input().split()))
d = defaultdict(int)
for i in A:
    d[i] += 1
for i in range(1,N+1):
    print((d[i]))

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

sig = [0] * N

for i in range(N-1):
  print((B.count(i+1)))
print((0))

#print(sig)
#for i in sig:
#  print(i)

# Optimized solution
N = int(eval(input()))
A = [0]
B = list(map(int, input().split()))
A += B
#print(A)

sig = [0] * N

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

#print(sig)
for i in sig:
  print(i)
# Original solution
n = int(eval(input()))
a = list(map(int,input().split()))
s = [0]*n

for i in range(max(a)):
	s[i] = a.count(i+1)
	
for i in range(n):
  	print((s[i]))

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

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

for i in range(n):
	print((c[i]))
# Original solution
n = int(eval(input()))
a = [int(x) for x in input().split()]
for i in range(1,n+1):
    print((a.count(i)))

# Optimized solution
N = int(eval(input()))
K = [0]*N
A = [int(i) for i in input().split()]

for i in range(N-1):
    K[A[i]-1] += 1
for i in K:
    print(i)
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
for i in range(n):
    print((a.count(i + 1)))


# Optimized solution
n = int(eval(input()))
a = list(map(int, input().split()))
result = [0] * n
for x in a:
    result[x-1] += 1
for v in result:
    print(v)
# Original solution
N = int(eval(input()))
An = [int(x) for x in input().split()]

for i in range(1, N+1):
    print((An.count(i)))

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

mylist = [0] * N

for i in An:
    mylist[i-1] = mylist[i-1] + 1

for i in mylist:
    print(i)
# Original solution
import collections
N = int(eval(input()))
A = list(map(int, input().split()))
count = collections.Counter(A)
for n in range(N):
  print((count[n+1]))

# Optimized solution
import collections
N = int(eval(input()))
A = list(map(int, input().split()))
count = collections.Counter(A)
for i in range(N):
  print((count[i+1]))
# Original solution
import collections
n = int(eval(input()))
a = list(map(int, input().split()))

a.sort()
a = collections.deque(a)
counter = 0
for i in range(1, n+1):
    while len(a) != 0:
        if i != a[0]: 
            break
        counter += 1
        a.popleft()    
    print(counter)
    counter = 0
    


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

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

for i in range(n):
    print((ans[i]))
# Original solution
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
N = int(eval(input()))
a = readints()
ans = [0]*(N+1)
for i in range(len(a)):
    for j in range(1, N+1):
        if a[i] == j:
            ans[j] += 1
for i in range(len(ans)-1):
    print((ans[i+1]))


# Optimized solution
import itertools
import math
import string
import collections
from collections import Counter
from collections import deque
import sys
sys.setrecursionlimit(2*10**5)
INF = 2**60


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


def nCr(n, r):
    return math.factorial(n)//(math.factorial(n-r)*math.factorial(r))


def has_duplicates2(seq):
    seen = []
    for item in seq:
        if not(item in seen):
            seen.append(item)
    return len(seq) != len(seen)


def divisor(n):
    divisor = []
    for i in range(1, n+1):
        if n % i == 0:
            divisor.append(i)
    return divisor


# coordinates
dx = [-1, -1, -1, 0, 0, 1, 1, 1]
dy = [-1, 0, 1, -1, 1, -1, 0, 1]
N = int(eval(input()))
a = readints()
ans = [0]*(N+1)
for i in range(len(a)):
    ans[(a[i])] += 1
for i in range(len(ans)-1):
    print((ans[i+1]))
# Original solution
n = int(eval(input()))
all = list(map(int,input().split()))

for i in range(1,n+1):
    count = 0
    for j in all:
        if(i == j ):
            count += 1
    print(count)






# Optimized solution
n = int(eval(input()))
all = list(map(int,input().split()))
result ={}
for i in range(n):
    result[i] = 0

for i in all:
    result[i-1] += 1

#print(result)
for i in range(n):
    print((result[i]))
# Original solution
from collections import Counter


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

c=Counter(a)
ck=list(Counter(a).keys())
for i in range(1,n+1):
    if i in ck:
        print((c[i]))
    else:
        print((0))

# Optimized solution
from collections import Counter


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



c=Counter(a)
ck=set(Counter(a).keys())
for i in range(1,n+1):
    if i in ck:
        print((c[i]))
    else:
        print((0))
# Original solution
n = int(eval(input()))
a = list(map(int, input().split()))
ans = [0] * n

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

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

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

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

print(("\n".join( map( str, ans))))
# Original solution
n =int(eval(input()))
s = list(map(int,input().split()))
l =[0]*n
i = 0
while i < n-1 :
     l[s[i]-1] += 1
     i += 1
for _ in range(n):
     print((l[_]))

# Optimized solution
n =int(eval(input()))
s = list(map(int,input().split()))
l =[0]*n
for i in range(n-1) :
     l[s[i]-1] += 1
for _ in range(n):
     print((l[_]))
# Original solution
n=int(eval(input()))
t = [0]*(n+1)
A = [int(i) for i in input().split()]
for i in range(n-1):
	t[A[i]]+=1
for i in range(1,n+1):
	print((t[i]))


# Optimized solution
n=int(eval(input()))
t= [0]*(n+1)
l=[int(i) for i in input().split()]
for i in l:
  t[i]+=1
for i in range(1,n+1):
  print((t[i]))
# Original solution
N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(1,N+1):
    print((A.count(i)))

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

for i in A:
    m[i-1] += 1
# print(m)
for i in range(N):
    print((m[i]))
# Original solution
n=int(eval(input()))
a=list(map(int,input().split()))
for i in range(n):
    print((a.count(i+1)))

# Optimized solution
n=int(eval(input()))
a=list(map(int,input().split()))
j=0
c=0
import sys
a.sort()

for i in range(1,n+1):
    while 1:
        if j==n-1:
            
            break
        if i!=a[j]:
            break
        else:
            c+=1
            j+=1
    print(c)
    c=0