output_description: For each of the members numbered 1, 2, ..., N, print the number of immediate
  subordinates it has, in its own line.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      A_2 ... A_N
attempt: """
  NTC here
  """
  
  #!/usr/bin/env python
  import os
  import sys
  from io import BytesIO, IOBase
  
  
  def iin():
      return int(input())
  
  
  def lin():
      return list(map(int, input().split()))
  
  
  def main():
      T = 1
      while T:
          T -= 1
          n = iin()
          a = lin()
          ans = [0] * (n)
          for i in a:
              ans[i - 1] += 1
          print(*ans, sep="\n")
  
  
  # region fastio
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  
  # endregion
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  A company has N members, who are assigned ID numbers 1, ..., N.
  
  Every member, except the member numbered 1, has exactly one immediate boss
  with a smaller ID number.
  
  When a person X is the immediate boss of a person Y, the person Y is said to
  be an immediate subordinate of the person X.
  
  You are given the information that the immediate boss of the member numbered i
  is the member numbered A_i. For each member, find how many immediate
  subordinates it has.
samples: [{"input": "5\n    1 1 2 2", "output": "2\n    2\n    0\n    0\n    0\n    \n\nThe member numbered 1 has two immediate subordinates: the members numbered 2\nand 3.\n\nThe member numbered 2 has two immediate subordinates: the members numbered 4\nand 5.\n\nThe members numbered 3, 4, and 5 do not have immediate subordinates.\n\n* * *"}, {"input": "10\n    1 1 1 1 1 1 1 1 1", "output": "9\n    0\n    0\n    0\n    0\n    0\n    0\n    0\n    0\n    0\n    \n\n* * *"}, {"input": "7\n    1 2 3 4 5 6", "output": "1\n    1\n    1\n    1\n    1\n    1\n    0"}]