Harryxun/sft_time huggingface dataset:
### BUGGY CODE ###

N = int(input())
num = 0
list1 = []
for i in range(N):
    taisho = input()
    if not taisho in list1:
        num += 1
        list1.append(taisho)
print(num)


### FIXED CODE ###

N = int(input())
list1 = set()
for i in range(N):
    taisho = input()
    if not taisho in list1:
        list1.add(taisho)
print(len(list1))
### BUGGY CODE ###

def exp(x):
  ans = 0
  for i in range(x+1):
    ans += i
  return ans / x

n, k = map(int, input().split())
p = list(map(int, input().split()))
  
ans = []
for i in range(n-k+1):
  sum = 0
  for j in range(k):
    sum += exp(p[i+j])
  ans.append(sum)

print(max(ans))

### FIXED CODE ###

def exp(x):
  return (1+x) / 2

n, k = map(int, input().split())
p = list(map(int, input().split()))
  
sum = 0
for i in range(k):
  sum += exp(p[i])
max = sum

for i in range(n-k):
  sum += exp(p[i+k]) - exp(p[i])
  if max < sum:
    max = sum

print(max)
### BUGGY CODE ###

def g(j,i):
  a=B[j-1][i-1]
  m=[max([B[y][x]+a-B[y][i-1]-B[j-1][x] for y in range(j,n+1)]) for x in range(i,n+1)]
  return max(m)
n=int(raw_input())
N=range(n)
B=[[0]*(n+1) for _ in range(n+1)]
for j in N:
  A=map(int,raw_input().split())
  s=0
  for i in N:
    s+=A[i]
    B[j+1][i+1]=B[j][i+1]+s
N=N[1:]+[n]
m=[max([g(j,i) for i in N]) for j in N]
print max(m)

### FIXED CODE ###

def f(m,b):
  s=0
  for k in N[j:]:
    s+=A[k]
    b[k]=max(b[k],0)+s
    m=max(b[k],m)
  return m,b

m=-1e9
n=int(raw_input())
N=range(n)
B=[[0]*(n+1) for _ in range(n+1)]
for _ in N:
  A=map(int,raw_input().split())
  for j in N: m,B[j]=f(m,B[j])
print m
### BUGGY CODE ###

import sys

rm = lambda: map(int, sys.stdin.buffer.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')

n, m, k = rm()
a = rl()
b = rl()

cnt = 0
lena = len(a)
lenb = len(b)
dp = [[inf]*(lenb + 1) for _ in range(lena + 1)]
dp[0][0] = 0
dp[0][1] = b[0]
dp[1][0] = a[0]

for i in range(lena):
    for j in range(lenb):
        dp[i][j+1] = dp[i][j] + b[j]
        dp[i+1][j] = dp[i][j] + a[i]
        if dp[i][j+1] <= k or dp[i+1][j] <= k:
            cnt = max(i+j+1, cnt)
        else:
            break
else:
    if dp[lena][lenb-1] + b[lenb-1] <= k:
        cnt += 1
print(cnt)











### FIXED CODE ###

import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np
from functools import reduce

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

n, m, k = rm()
a = rl()
b = list(itertools.accumulate(rl()))
if a[0] > k:
    ans = 0
else:
    left = 0
    right = m
    while right - left > 1:
        j = (left + right) // 2
        if b[j] > k:
            right = j
        else:
            left = j
    ans = left + 1
t = 0
b0 = b[0]
for cnt, i in enumerate(a, 1):
    t += i
    if t > k:
        break
    if b0 > k-t:
        ans = max(ans, cnt)
        continue
    left = 0
    right = m
    while right - left > 1:
        j = (left + right) // 2
        if b[j] > k-t:
            right = j
        else:
            left = j
    ans = max(ans, cnt + left + 1)
print(ans)
### BUGGY CODE ###

n, m = map(int, input().split())
a = [int(input()) for i in range(m)]
mod = 10**9+7
dp = [0]*(n+1)
dp[0], dp[1] = 1, 1
if 1 in a:
    dp[1] = 0
for i in range(2, n+1):
    if i not in a:
        dp[i] = dp[i-1] + dp[i-2]
        dp[i] %= mod
print(dp[n])

### FIXED CODE ###

n, m = map(int, input().split())
a = [int(input()) for i in range(m)]
mod = 10**9+7
dp = [1]*(n+1)
for i in a:
    dp[i] = 0
for i in range(2, n+1):
    if dp[i] > 0:
        dp[i] = dp[i-1] + dp[i-2]
        dp[i] %= mod
print(dp[n])
### BUGGY CODE ###

import math, queue

h, w = map(int, input().split(" "))
sY, sX = map(int, input().split(" "))
gY, gX = map(int, input().split(" "))
smap = [list(input()) for _ in range(h)]
visited = [[False for _ in range(w)] for _ in range(h)]

for y in range(h):
    for x in range(w):
        if smap[y][x] == ".":
            smap[y][x] = 100000000000

sY, sX = sY - 1, sX - 1
gY, gX = gY - 1, gX - 1

q = queue.deque()
q.append([sY, sX])
smap[sY][sX] = 0
visited[sY][sX] = True

mv0 = [[-1, 0], [1, 0], [0, -1], [0, 1]]
mv1 = [[-1, -1], [1, -1], [-1, 1], [1, 1], [-2, -2], [-2, -1],
       [-2, 0], [-2, 1], [-2, 2], [-1, 2], [0, 2], [1, 2], [2, 2], [2, 1],
       [2, 0], [2, 1], [2, -2], [1, -2], [0, -2], [-1, -2]]

cnt = 0
while len(q) != 0:
    cnt += 1
    crntY, crntX = q.popleft()
    for i, [stepY, stepX] in enumerate(mv0 + mv1):
        nextY = crntY + stepY
        nextX = crntX + stepX
        if nextY < 0 or h <= nextY or nextX < 0 or w <= nextX:
            continue
        if visited[nextY][nextX] or smap[nextY][nextX] == "#":
            continue
        cost = smap[crntY][crntX]
        if i >= 4:
            cost += 1
            q.append([nextY, nextX])
        else:
            q.appendleft([nextY, nextX])
        smap[nextY][nextX] = min(cost, smap[nextY][nextX])
    visited[crntY][crntX] = True

if smap[gY][gX] == 100000000000:
    print(-1)
else:
    print(smap[gY][gX])

### FIXED CODE ###

import sys
from collections import deque

H, W = map(int, sys.stdin.readline().split())
cy, cx = map(int, sys.stdin.readline().split())
gy, gx = map(int, sys.stdin.readline().split())
cy -= 1
cx -= 1
gy -= 1
gx -= 1
grid = []
for _ in range(H):
    grid.append(sys.stdin.readline().strip())
q = deque()
q.append((cx, cy, 0))
visited_d = {}
visited_e = {}
ans = float("inf")
while q:
    x, y, e = q.popleft()
    if (x, y) in visited_e and visited_e[(x, y)] <= e:
        continue
    visited_e[(x, y)] = e
    for dx, dy in ((1, 0), (-1, 0), (0, 1), (0, -1)):
        nx = x + dx
        ny = y + dy
        if 0 <= nx < W and 0 <= ny < H and grid[ny][nx] != "#":
            if nx == gx and ny == gy:
                ans = min(ans, e)
                continue
            if (nx, ny) not in visited_e:
                q.appendleft((nx, ny, e))
    for dx in range(-2, 3):
        for dy in range(-2, 3):
            if abs(dx) == 1 and dy == 0 or abs(dy) == 1 and dx == 0:
                continue
            nx = x + dx
            ny = y + dy
            if 0 <= nx < W and 0 <= ny < H and grid[ny][nx] != "#":
                if nx == gx and ny == gy:
                    ans = min(ans, e + 1)
                    continue
                if (nx, ny) not in visited_e:
                    q.append((nx, ny, e + 1))
print(-1 if ans == float("inf") else ans)
### BUGGY CODE ###

N,K = input().split(" ")
N = int(N)
K = int(K)

hList = []
for i in range(0,N):
    hList.append(int(input()))

hList.sort()
tousa = []

for i in range(0,N-1):
    tousa.append(abs(hList[i] - hList[i+1]))

sumList = []

for i in range(0,N-K+1):
    sm = 0
    for j in range(0,K-1):
        sm = tousa[i+j] + sm
    sumList.append(sm)

sumList.sort()
print(sumList[0])


### FIXED CODE ###

N,K = map(int,input().split())
h =[]
dif = []
for n in range(0,N):
    h.append(int(input()))

h.sort()

m = 10**10

for i in range(0,N-K+1):
    m = min(m,abs(h[i] - h[i+K-1]))

print(m)
### BUGGY CODE ###

N = input()
alist = list(map(int,input().split()))
s = 0
i = 0
for x in alist:
  num = 0
  i += 1
  j = 0
  for y in alist:
    j += 1
    if i != j:
      if x % y == 0:
        break
      else:
        num += 1
  if num == int(N)-1:
    s += 1
print(s)

### FIXED CODE ###

'''
Created on 2020/08/23

@author: harurun
'''
def main():
  from collections import Counter
  import sys
  pin=sys.stdin.readline
  pout=sys.stdout.write
  perr=sys.stderr.write

  ans=0
  N=int(pin())
  A=list(map(int,pin().split()))
  c=Counter(A)
  t=max(A)
  dp=[True]*t
  for i in A:
    if dp[i-1]:
      n=2*i
      while n<=t:
        dp[n-1]=False
        n+=i
  for k in A:
    if c[k]==1 and dp[k-1]:
      ans+=1
  print(ans)
  return
main()
### BUGGY CODE ###

import numpy as np
from collections import deque
N,M = [int(i) for i in input().split()]
roads = []
for _ in range(M):
    A,B = [int(i) for i in input().split()]
    roads.append([A,B])
    roads.append([B,A])
roads = np.array(roads)
places = [0]*(N+1)
places[1] = 1
q = deque([1])
while min(places[1:]) == 0:
    i = q.pop()
    L = roads[roads[:,0] == i][:,1]
    for j in L:
        if places[j] == 0:
            places[j] = i
            q.appendleft(j)
print("Yes")
for i in range(2,N+1):
    print(places[i])

### FIXED CODE ###

import numpy as np
from collections import deque
N,M = [int(i) for i in input().split()]
roads = [[] for _ in range(N+1)]
for _ in range(M):
    A,B = [int(i) for i in input().split()]
    roads[A].append(B)
    roads[B].append(A)
places = [0]*(N+1)
places[1] = 1
q = deque([1])
vis = [False]*(N+1)
vis[1] = True
while q:
    now = q.popleft()
    L = roads[now]
    for j in L:
        if vis[j]:
            continue
        vis[j] = True
        places[j] = now
        q.append(j)

print("Yes")
s = "\n".join(map(str, places[2:]))
print(s)
### BUGGY CODE ###

N=int(input())
S=[input().split() for i in range(N)]
A=[]
L=len(S)
while L>0:
    S=[s for s in S if s!=S[0]]
    A.append(L-len(S))
print(max(A))




### FIXED CODE ###

n = int(input())
s = [input() for _ in range(n)]
d = {}
for w in s:
    if w not in d:
        d[w] = 0
    d[w] += 1
d2 = sorted(d.items(), key=lambda x:x[1], reverse=True)
maxcnts = [w[0] for w in d2 if w[1] == d2[0][1]]
maxcnts.sort()
for ans in maxcnts:
    print(ans)
### BUGGY CODE ###

a,b,x = map(int,input().split())

ans = 0
for i in range(a,b+1):
    if i%x == 0:
        ans += 1
print(ans)

### FIXED CODE ###

a,b,x = map(int,input().split())
def f(n,x):
    if n == -1:
        return 0
    else:
        return n//x + 1

print(f(b,x)-f(a-1,x))
### BUGGY CODE ###

#!/usr/bin/env python3
# vim: set fileencoding=utf-8

# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation


"""Module docstring
"""

import sys


def solve(s, t):
    dp = [[0 for _ in range(len(s) + 1)] for _ in range(len(t) + 1)]
    for i in range(1, len(t) + 1):
        for j in range(1, len(s) + 1):
            if s[j - 1] == t[i - 1]:
                dp[i][j] = 1 + dp[i - 1][j - 1]
            else:
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
    i = len(t)
    j = len(s)
    selected = []
    while i > 0 and j > 0:
        if t[i - 1] == s[j - 1]:
            selected.append(t[i - 1])
            i -= 1
            j -= 1
        elif dp[i - 1][j] > dp[i][j - 1]:
            i -= 1
        else:
            j -= 1
    return "".join(reversed(selected))


def do_job():
    "Do the work"
    s = input()
    t = input()
    result = solve(s, t)
    print(result)


def print_output(testcase, result) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case #{}: {}".format(testcase + 1, result))


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    do_job()
    return 0


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    sys.exit(main())


### FIXED CODE ###

#!/usr/bin/env python3
# vim: set fileencoding=utf-8

# pylint: disable=unused-import, invalid-name, missing-docstring, bad-continuation


"""Module docstring
"""

import sys


def solve(s, t):
    v = [0] * (len(s) + 1)
    dp = [v]
    for _, ti in enumerate(t, 1):
        u, v = v, v.copy()
        dp.append(v)
        ll, ul = 0, 0
        for j, sj in enumerate(s, 1):
            uj = u[j]
            if sj == ti:
                v[j] = 1 + ul
                ll = 1 + ul
            else:
                if ll > uj:
                    v[j] = ll
                else:
                    ll = uj
            ul = uj
    i = len(t)
    j = len(s)
    k = dp[i][j]
    selected = []
    while k > 0:
        if dp[i - 1][j] == k:
            i -= 1
        elif dp[i][j - 1] == k:
            j -= 1
        else:
            selected.append(t[i - 1])
            k -= 1
            i -= 1
            j -= 1
    return "".join(selected[::-1])


def do_job():
    "Do the work"
    s = input()
    t = input()
    result = solve(s, t)
    print(result)


def print_output(testcase, result) -> None:
    "Formats and print result"
    if result is None:
        result = "IMPOSSIBLE"
    print("Case #{}: {}".format(testcase + 1, result))


def main(argv=None):
    "Program wrapper."
    if argv is None:
        argv = sys.argv[1:]
    do_job()
    return 0


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    sys.exit(main())
### BUGGY CODE ###

# -*- coding: utf-8 -*-
import sys


def get_num():
    return int(input())


def get_nums(n):
    res = [0 for _ in range(n)]
    for i in range(n):
        res[i] = int(input())
    return res


def get_numbers():
    return map(int, input().split())

n, q = get_numbers()
s = input()

ac_idx = list()
for i in range(n - 1):
    if s[i:i + 2] == 'AC':
        ac_idx.append(i + 1)

ans = list()
for i in range(q):
    l, r = get_numbers()
    ans.append(len([idx for idx in ac_idx if idx >= l and idx < r]))

for a in ans:
    print(a)

### FIXED CODE ###

# -*- coding: utf-8 -*-
import sys


def get_num():
    return int(input())


def get_nums(n):
    res = [0 for _ in range(n)]
    for i in range(n):
        res[i] = int(input())
    return res


def get_numbers():
    return map(int, input().split())

n, q = get_numbers()
s = input()

dp = [0 for _ in range(n + 1)]
for i in range(1, n):
    dp[i + 1] = dp[i]
    if s[i - 1:i + 1] == 'AC':
        dp[i + 1] += 1

ans = list()
for i in range(q):
    l, r = get_numbers()
    ans.append(dp[r] - dp[l])

for a in ans:
    print(a)
### BUGGY CODE ###

n = int(input())
a = input().split()
aa = [int(a[i]) for i in range(n)]
b = 1
for i in range(n):
  s = list(str(aa[i]))
  ss = int(s[-1])
  if ss == 0 or ss == 2 or ss == 4 or ss == 6 or ss == 8:
  	b = b * aa[i]

c = 0
cnt = 0
while c < 1:
  if b % 2 == 0:
    b = b // 2
    cnt = cnt + 1
  else:
    c = 1
print(cnt)



### FIXED CODE ###

n = int(input())
a = input().split()
aa = [int(a[i]) for i in range(n)]
b = 1
for i in range(n):
  s = list(str(aa[i]))
  ss = int(s[-1])
  if ss == 0 or ss == 2 or ss == 4 or ss == 6 or ss == 8:
  	b = b * aa[i]

c = 0
cnt = 0
while c < 1:
  if b % 2 == 0:
    b = b // 2
    cnt = cnt + 1
  else:
    c = 1
print(cnt)
### BUGGY CODE ###

K = int(input())

count = 1
num = 7
if K % 2 == 0:
    count = -1
else:
    while True:
        if num % K == 0:
            break
        num = (num*10 + 7) % K
        count += 1
print(count)

### FIXED CODE ###

K = int(input())

count = 1
num = 7
if K % 2 == 0 or K % 5 == 0:
    count = -1
else:
    while True:
        if num % K == 0:
            break
        num = (num*10 + 7) % K
        count += 1
        if count >= 10**6 * 10**5:
            count = -1
            break
print(count)
### BUGGY CODE ###

import numpy as np

def update(A, N):
    B = [0] * N
    for i, t in enumerate(A):
        l = max(0, i - t)
        r = min(N - 1, i + t)
        B[l] += 1
        if (r + 1 < N):
            B[r + 1] -= 1
    return np.cumsum(B)

def main():
    N, K = map(int, input().split())
    A = list(map(int, input().split()))
    for _ in range(0, min(42, K)):
        A = update(A, N)
    print(" ".join([str(item) for item in A]))

if __name__ == "__main__":
    main()

### FIXED CODE ###

import sys
import numpy as np
from numba import njit

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

@njit('(i8[::1],)', cache=True)
def update(A):
    N = len(A)
    B = np.zeros_like(A)
    for i, x in enumerate(A):
        l = max(0, i - x)
        r = min(N - 1, i + x)
        B[l] += 1
        if r + 1 < N:
            B[r + 1] -= 1
    B = np.cumsum(B)
    return B

N, K = map(int, readline().split())
A = np.array(read().split(), np.int64)

K = min(K, 100)
for _ in range(K):
    A = update(A)
print(' '.join(A.astype(str)))
### BUGGY CODE ###

# coding: utf-8

import itertools
import math

    
def my_generator(C):
    for v in itertools.permutations(C):
        yield v


def check(C):
    A = [0 for i in range(M+1)]
    for i in range(N):
        A = [a + b for a, b in zip(A, C[i])]
        b = [i for i in range(M+1) if A[i] < X]
        if len(b) == 0:
            return A[0]
    else:
        print(-1)
        exit()

N, M, X = map(int, input().split())

C = [list(map(int, input().split())) for _ in range(N)]

genlst = my_generator(C)
lenn = math.factorial(N)
m = 0
for i in range(lenn):
    C = next(genlst)

    if i == 0:
        m = check(C)
    else:
        m = min(m, check(C))
print(m)

### FIXED CODE ###

# coding: utf-8
N, M, X = map(int, input().split())
C = [list(map(int, input().split())) for _ in range(N)]
n = len(C)
m = -1
for i in range(2 ** n):
    A = [0 for i in range(M+1)]
    total = 0
    for j in range(n):
        if((i >> j) & 1):
            A = [a + b for a, b in zip(A, C[j])]
            B = [k for k in range(1, M+1) if A[k] < X]
            if len(B) == 0:
                if m == -1:
                    m = A[0]
                else:
                    m = min(m, A[0])
                break
print(m)
### BUGGY CODE ###

from collections import deque

N = int(input())

S = []
for _ in range(N):
    S.append(int(input()))

Q = deque([(0, 0)])

R = 0
while Q:
    i, pt = Q.popleft()
    if i == N and pt % 10 != 0:
        R = max(pt, R)
    if i < N:
        Q.append((i + 1, pt + S[i]))
        Q.append((i + 1, pt))

print(R)
    


### FIXED CODE ###

from collections import deque

N = int(input())

S = []
for _ in range(N):
    S.append(int(input()))

SA = sum(S)

if SA % 10 == 0:
    SS = [s for s in S if s % 10 != 0]
    if len(SS) > 0:
        SA -= min(SS)
    else:
        SA = 0

print(SA)
### BUGGY CODE ###

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

def f(x: int) -> int:
    return (A * x) // B - A * (x // B)

print(max(f(x) for x in range(N + 1)))


### FIXED CODE ###

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

def f(x: int) -> int:
    return (A * x) // B - A * (x // B)

x = min(N, B - 1)
print(f(x))
### BUGGY CODE ###

N, Q = map(int,input().split())
l = [list(map(int,input().split())) for _ in range(N-1)]
m = [list(map(int,input().split())) for _ in range(Q)]
ll = [0]*N
bb = [[i] for i in range(1,N+1)]
for i in l:
    bb[i[0]-1].append(i[1])
for i in m:
    ll[i[0]-1] += int(i[1])
ans = [0]*N
# print("bb=",bb)
# print("ll=",ll)
for i in range(N):
    for k in bb[i]:
        if k == i+1:
            ans[i] += ll[i]
        else:
            ll[k-1] += ll[i]
print(*ans)

### FIXED CODE ###

n, q = map(int, input().split())
ki = [0] * (n + 1)
for i in range(n - 1):
    a, b = map(int, input().split())
    ki[b] = a
# print("ki=",ki)

c = [0] * (n + 1)
for i in range(q):
    p, x = map(int, input().split())
    c[p] += x
# print("c=",c)

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

print(" ".join(map(str, c[1:])))
### BUGGY CODE ###

s = list(input())
n = len(s)
ans = 0
if n <= 3:
    print(0)
    exit()
elif n == 4:
    if int(s[0]*1000+s[1]*100+s[2]*10+s[3]) % 2019 == 0:
        print(1)
        exit()
    else:
        print(0)
        exit()
elif n > 4:
    for i in range(n-3):
        kar = int(s[i])*100 + int(s[i+1])*10 + int(s[i+2])
        for j in range(i+3,n):
            kar = (kar*10 + int(s[j])) %2019
            if kar == 0:
                ans += 1
print(ans)

### FIXED CODE ###

s = list(input())
p = [0 for i in range(2019)]
n = len(s)
ans = 0
kar = 0
dig = 1
for i in range(n):
    kar = (kar + int(s[n-1-i])*dig)%2019
    dig = (dig*10)%2019
    p[kar] += 1

for i in range(2019):
    ans += p[i]*(p[i]-1)//2
    if i == 0:
        ans += p[i]
print(ans)
### BUGGY CODE ###

A,B = map(int,input().split())
#A,B = bin(A),bin(B)
total = A
for i in range(A+1,B+1,1):
    total = total^i
print(total)

### FIXED CODE ###

def xor(x):
    res = [x,1,x+1,0]
    return res[x%4]

A,B = map(int,input().split())
print(xor(A-1)^xor(B))
### BUGGY CODE ###

s=input()
s=list(s)
n=len(s)
for i in range(0,n):
    if(s[i]=='?'):
        s[i]='D'
ans=""
for h in s:
    ans+=h
print(ans)

### FIXED CODE ###

s=input()
n=len(s)
for i in range(0,n):
    if(s[i]=='?'):
        print('D',end="")
    else:
        print(s[i],end="")
### BUGGY CODE ###

from sys import exit
N = int(input())
n = int(N ** 0.5)
for i in range(n, N + 1):
  if N % i == 0:
    ans = i + N // i - 2
    print(ans)
    exit()


### FIXED CODE ###

N = int(input())
n = int(N ** 0.5)
for i in range(n, 0, -1):
  if N % i == 0:
    ans = i + N // i - 2
    print(ans)
    break
### BUGGY CODE ###

r,g,b,n=map(int,input().split())
ans=0
for i in range(n+1):
  if r*i>n:
    break
  for j in range(n+1):
    if r*i+g*j>n:
      break
    if (n-r*i-g*j)%b==0:
      ans+=1
print(ans)

### FIXED CODE ###

r,g,b,n=map(int,input().split())
m=[r,g,b]
m.sort(reverse=1)
r,g,b=m[0],m[1],m[2]
ans=0
if m==[1,1,1]:
  print((n+2)*(n+1)//2)
else:
  for i in range(n+1):
    if r*i>n:
      break
    for j in range(n+1):
      if r*i+g*j>n:
        break
      if (n-r*i-g*j)%b==0:
        ans+=1
  print(ans)
### BUGGY CODE ###

#O(nm) = O(60n)で解けるはず・・・！
n = int(input())
*l, = map(int,input().split())
#2進数の桁の出現数をカウントする。
lone = [0]*60
for i in range(n):
#  m = l[i]
  s = bin(l[i])[2:]
  for j in range(len(s)):
    lone[j] += int(s[-j-1])
#  for j in range(59,-1,-1):
#    if m >= 2**j:
#      m -= 2**j
#      lone[j] += 1

ans = 0
for i in range(60):
  ans += 2**i*lone[i]*(n-lone[i])
print(ans%(10**9+7))

### FIXED CODE ###

#O(nm) = O(60n)で解けるはず・・・！
n = int(input())
l = list(map(int,input().split()))
#2進数の桁の出現数をカウントする。
lone = [0]*60
for i in range(n):
  s = bin(l[i])[2:]
  for j in range(len(s)):
    lone[j] += int(s[-j-1])
ans = 0
for i in range(60):
  ans += (2**i*lone[i]*(n-lone[i]))%(10**9+7)
print(ans%(10**9+7))
### BUGGY CODE ###

N=int(input())
Boss=list(map(int, input().split()))
Boss.insert(0, 0)
for i in range(N):
    print(Boss.count(i+1))

### FIXED CODE ###

import collections
N=int(input())
Boss=list(map(int, input().split()))
AA=collections.Counter(Boss)
for i in range(N):
    print(AA[i+1])