Polycarp has $n$ coins, the value of the $i$-th coin is $a_i$. Polycarp wants to distribute all the coins between his pockets, but he cannot put two coins with the same value into the same pocket.

For example, if Polycarp has got six coins represented as an array $a = [1, 2, 4, 3, 3, 2]$, he can distribute the coins into two pockets as follows: $[1, 2, 3], [2, 3, 4]$.

Polycarp wants to distribute all the coins with the minimum number of used pockets. Help him to do that.


-----Input-----

The first line of the input contains one integer $n$ ($1 \le n \le 100$) — the number of coins.

The second line of the input contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$) — values of coins.


-----Output-----

Print only one integer — the minimum number of pockets Polycarp needs to distribute all the coins so no two coins with the same value are put into the same pocket.


-----Examples-----
Input
6
1 2 4 3 3 2

Output
2

Input
1
100

Output
1

Difficulty: EASY
Tags: Implementation

Starter code:

Solutions:
n = int(input())
l = list(map(int, input().split()))
x = []
i = 1
for i in range(1000):
	p = l.count(i)
	x.append(p)
z = max(x)
print(z)


n = int(input())
l = [0] * 101
for i in [int(_) for _ in input().split()]:
	l[i] += 1
print(max(l))


n = int(input())
a = [int(x) for x in input().split()]
c = set(a)
k = []
for i in c:
	k.append(a.count(i))
print(max(k))


n = int(input())
monets = list(map(int, input().split()))
lint = [0] * max(monets)
for i in monets:
	lint[i - 1] += 1
print(max(lint))


n = int(input())
l = list(map(int, input().split()))
p = set(l)
m = []
for i in p:
	m.append(l.count(i))
print(max(m))


n = int(input())
a = [int(i) for i in input().strip().split()]
al = set(a)
maxcount = 0
for i in al:
	maxcount = max(maxcount, a.count(i))
print(maxcount)


from collections import Counter
n = int(input())
money = input().split()
for i in range(n):
	money[i] = int(money[i])
counter = Counter(money)
print(counter.most_common()[0][1])


n = int(input())
a = list(map(int, input().split()))
a1 = list(set(a))
b = []
for i in range(0, len(a1)):
	b.append(a.count(a1[i]))
print(max(b))


n = int(input())
arr = [0] * 101
a = [int(x) for x in input().split()]
for i in range(n):
	arr[a[i]] += 1
print(max(arr))


n = int(input())
a = list(map(int, input().split()))
count = [0] * (max(a) + 1)
for elem in a:
	count[elem] += 1
print(max(count))


n = int(input())
a = list(map(int, input().split()))
b = [0] * 100
for i in a:
	b[i - 1] += 1
print(max(b))


try:
	n = int(input())
	arr = list(map(int, input().split()))
	res = 0
	for ele in arr:
		res = max(res, arr.count(ele))
	print(res)
	pass
except Exception:
	pass


from collections import Counter as c
n = int(input())
arr = list(map(int, input().split()))
a = c(arr)
b = max([value for value in a.values()])
print(b)


import sys
n = int(input())
an = list(map(int, sys.stdin.readline().split()))
d = {}
ans = 0
for a in an:
	if a not in d:
		d[a] = 1
	else:
		d[a] = d[a] + 1
	ans = max(ans, d[a])
print(ans)


n = int(input())
m = list(map(int, input().split()))
p = []
if n == 1:
	print(1)
else:
	for i in range(n):
		count = 0
		for j in range(n):
			if m[i] == m[j]:
				count = count + 1
		p.append(count)
	x = max(p)
	print(x)


import sys
n = int(sys.stdin.readline())
numbers = sys.stdin.readline().strip('\n').split(' ')
value_to_occurrence = {}
for num in numbers:
	if num not in value_to_occurrence.keys():
		value_to_occurrence[num] = 1
	else:
		value_to_occurrence[num] += 1
ans = -1000000
for val in value_to_occurrence.values():
	ans = max(ans, val)
print(ans)


n = int(input())
A = list(map(int, input().split()))
xx = [0] * 100
for i in range(n):
	x = A[i]
	xx[x - 1] = xx[x - 1] + 1
print(max(xx))


n = int(input())
x = 0
a = [int(n) for n in input().split(' ')]
for i in range(len(a)):
	if a.count(a[i]) > x:
		x = a.count(a[i])
print(x)


n = int(input())
a = list(map(int, input().split()))
b = []
for i in a:
	c = a.count(i)
	b.append(c)
print(max(b))


from collections import Counter
input()
l = list(map(int, input().split()))
print(max(Counter(l).values()))


def main():
	dic = {}
	n = int(input())
	max = 0
	number = input().split(' ')
	for i in range(len(number)):
		if number[i] in dic:
			dic[number[i]] += 1
		else:
			dic[number[i]] = 1
		if dic[number[i]] > max:
			max = dic[number[i]]
	print(max)
main()


n = int(input())
nums = list(map(int, input().split()))
result = 0
for n in nums:
	result = max(result, nums.count(n))
print(result)


n = int(input())
priorities = [int(num) for num in input().split()]
counts = [0] * 101
for num in priorities:
	counts[num] += 1
print(max(counts))


n = int(input())
arr = list(map(int, input().split()))
arr2 = [0] * 101
for i in range(0, n):
	arr2[arr[i]] += 1
print(max(arr2))


from collections import Counter
input()
counter = Counter(map(lambda n: int(n), input().split()))
(_, min_pockets) = counter.most_common(1)[0]
print(min_pockets)


from collections import Counter

def solve(a):
	c = Counter(a)
	return c.most_common(1)[0][1]
n = input()
a = [int(x) for x in input().split()]
print(solve(a))


n = int(input())
a = list(map(int, input().split()))
cnt = [0 for i in range(150)]
for i in range(n):
	cnt[a[i]] += 1
print(max(cnt))


input()
n = list(map(int, input().split()))
f = 0
for i in n:
	if n.count(i) > f:
		f = n.count(i)
print(f)


from collections import Counter
n = int(input())
l1 = list(map(int, input().split()))
d = Counter(l1)
print(max(d.values()))


test_cases = int(input())
list_num = input().split(' ')
count = [0] * 101
for i in range(len(list_num)):
	list_num[i] = int(list_num[i])
	count[list_num[i]] += 1
print(max(count))


n = int(input())
s = input().split()
print(max((s.count(i) for i in s)))


n = int(input())
l = list(map(int, input().split()))
m = 0
for i in range(n):
	c = l.count(l[i])
	if m < c:
		m = c
print(m)


def solve(a):
	temp = []
	for i in a:
		temp.append(a.count(i))
		answer = max(temp)
	return answer
_ = input()
a = list(map(int, input().strip().split()))
print(solve(a))


from collections import defaultdict
x = int(input())
a = list(map(int, input().split()))
d = defaultdict(int)
k = 0
for i in a:
	d[i] += 1
	k = max(k, d[i])
print(k)


n = int(input())
arr = list(map(int, input().split()))
dis = []
for i in range(n):
	if arr[i] not in dis:
		dis.append(arr[i])
cc = []
c = 0
for i in range(len(dis)):
	for j in range(n):
		if dis[i] == arr[j]:
			c = c + 1
	cc.append(c)
	c = 0
print(max(cc))


n = int(input())
coins = list(map(int, input().split(' ')))
dict = {}
for coin in coins:
	if coin in dict:
		dict[coin] += 1
	else:
		dict[coin] = 1
print(max(dict.values()))


n = int(input())
a = [int(i) for i in input().split()]
array = [0] * 100
for i in range(n):
	x = a[i]
	array[x - 1] += 1
print(max(array))


N = int(input())
A = list(map(int, input().split()))
ans = 0
for a in A:
	ans = max(ans, A.count(a))
print(ans)


from collections import Counter

def go():
	n = int(input())
	a = Counter([int(i) for i in input().split(' ')])
	return max(dict(a).values())
	return
print(go())


a = int(input())
b = list(map(int, input().split()))
D = {}
maximum = 0
for i in b:
	if i in D:
		D[i] += 1
	else:
		D[i] = 1
	if D[i] > maximum:
		maximum = D[i]
print(maximum)


n = int(input())
a = [int(i) for i in input().split()]
freq = {}
pock = 1
for i in a:
	if i in freq:
		freq[i] += 1
		if freq[i] > pock:
			pock = freq[i]
	else:
		freq[i] = 1
print(pock)


n = int(input())
m = list(map(int, input().split()))
l = []
for i in range(n):
	for j in range(1, 101):
		l.append(m.count(j))
print(max(l))


a = int(input())
if a == 1:
	s = input()
	print(1)
else:
	d = {}
	s = input().split()
	for i in s:
		if i in d:
			d[i] += 1
		else:
			d[i] = 1
	g = []
	for i in d:
		g.append(d[i])
	for i in d:
		if max(g) == d[i]:
			print(d[i])
			break


n = int(input())
vals = [int(num) for num in input().split()]
count = []
for i in vals:
	c = vals.count(i)
	count.append(c)
print(max(count))


n = int(input())
a = list(map(int, input().split()))
maxq = 0
while a != []:
	r = 0
	p = a[0]
	while p in a:
		a.remove(p)
		r += 1
	if r > maxq:
		maxq = r
print(maxq)


n = int(input())
a = input().split()
max = 1
s = [int(a[0])]
f = [1]
for i in range(1, n):
	look = True
	for j in range(len(s)):
		if int(a[i]) == s[j]:
			f[j] += 1
			look = False
			if f[j] > max:
				max = f[j]
			break
	if look:
		s += [int(a[i])]
		f += [1]
print(max)


arr = [0] * 101
n = int(input())
a = list(map(int, input().split()))
for i in a:
	arr[i] += 1
count = 0
run = True
while run:
	run = False
	for i in range(1, 101):
		if arr[i] > 0:
			arr[i] -= 1
		if arr[i] > 0:
			run = True
	count += 1
print(count)


input()
a = list(map(int, input().split()))
b = []
for i in range(0, 101):
	b.append(0)
for i in a:
	b[i] += 1
print(max(b))


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0)
n = int(input())
print(max(Counter(get_list()).values()))


n = int(input())
mas = list(map(int, input().split()))
ms = [0] * 101
for i in range(n):
	ms[mas[i]] += 1
print(max(ms))


n = int(input())
a = list(map(int, input().split()))
ans = max(map(lambda x: a.count(x), a))
print(ans)


n = int(input(''))
a = [int(x) for x in input().split()]
a.sort()
p = []
c = 1
for x in range(n - 1):
	if a[x + 1] == a[x]:
		c += 1
	else:
		p.append(c)
		c = 1
p.append(c)
print(max(p))


n = int(input())
a = list(map(int, input().split()))
pockets = 0
for dig in a:
	pockets = max(pockets, a.count(dig))
print(pockets)


_ = input()
hash_map = dict()
max_value = 0
for i in input().split():
	hash_map[i] = hash_map.get(i, 0) + 1
	max_value = max(hash_map[i], max_value)
print(max_value)


n = int(input())
arr = list(map(int, input().split()))
cou = 1
for i in arr:
	if cou < arr.count(i):
		cou = arr.count(i)
print(cou)


from collections import defaultdict as dd
n = int(input())
a = [int(i) for i in input().split()]
ct = 1
dnary = dd(int)
for i in a:
	dnary[i] += 1
	ct = max(ct, dnary[i])
print(ct)


n = int(input())
l = list(map(int, input().split()))
a = [0] * 101
for i in range(n):
	a[l[i]] += 1
print(max(a))


import statistics
from statistics import mode
n = int(input())
l = list(map(int, input().split()))
x = mode(l)
count = 0
for i in range(n):
	if l[i] == x:
		count = count + 1
print(count)


from collections import OrderedDict
x = int(input())
y = list(map(int, input().split()))

def group_list(lst):
	res = [(el, lst.count(el)) for el in lst]
	return list(OrderedDict(res).items())
z = []
for (x, y) in group_list(y):
	z.append(y)
z.sort()
print(z[-1])


number = int(input())
lista = input().split()
lista1 = [i for i in lista if lista.count(i) >= 2]
lista = [lista1.count(j) for j in lista1]
if lista == []:
	print(1)
else:
	print(max(lista))


n = int(input())
a = list(map(int, input().split()))
ans = 0
for x in a:
	ans = max(ans, a.count(x))
print(ans)


t = int(input())
x = []
c = 0
a = [int(i) for i in input().split()]
for i in range(t):
	if a[i] not in x:
		x.append(a[i])
for i in range(len(x)):
	d = a.count(x[i])
	if d > c:
		c = d
print(c)


input()
k = input().split()
uniq = []
max = []
maxi = 0
ans = 1
for i in range(len(k)):
	if k[i] not in uniq:
		uniq.append(k[i])
		max.append(0)
	else:
		max[uniq.index(k[i])] += 1
for i in range(len(max)):
	if max[i] > maxi:
		maxi = max[i]
if maxi == 0:
	print(1)
else:
	print(maxi + 1)


n = int(input())
lst = map(int, input().split())
d = {}
m = 0
for i in lst:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
for i in d:
	m = max(m, d[i])
print(m)


from collections import Counter
n = int(input())
arr = [int(i) for i in input().split()]
x = Counter(arr)
print(max(x.values()))


from collections import Counter
n = int(input())
l = list(map(int, input().split()))
m = Counter(l)
m = sorted(m.items(), key=lambda i: i[1], reverse=True)
for i in m:
	print(i[1])
	break


n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(len(a)):
	if a.count(a[i]) > ans:
		ans = a.count(a[i])
print(ans)


n = int(input())
l = list(map(int, input().split()))
s = set(l)
a = []
for i in s:
	p = l.count(i)
	a.append(p)
print(max(a))


n = int(input())
s = map(int, input().strip().split(' '))
t = [0 for i in range(101)]
for i in s:
	t[i] += 1
print(max(t))


n = int(input())
a = list(map(int, input().split()))
res = []
for i in a:
	add = True
	for r in res:
		if i not in r:
			r.add(i)
			add = False
			break
	if add:
		res.append({i})
print(len(res))


from collections import Counter
n = int(input())
l = list(map(int, input().strip().split()))
x = list(Counter(l).values())
print(max(x))


first_line = input()
second_line = input()
n = int(first_line)
coins = second_line.split()
min_used = 1
for i in range(0, n):
	count = 1
	current = coins[i]
	for j in range(i + 1, n):
		if coins[j] == current:
			count += 1
	if count > min_used:
		min_used = count
print(min_used)


n = int(input())
a = [int(i) for i in input().split()]
b = [0] * 100
for i in range(n):
	b[a[i] - 1] += 1
print(max(b))


n = int(input())
s = input().split()
seted = set(s)
my_list = []
for i in seted:
	x = s.count(i)
	my_list.append(x)
print(max(my_list))


import sys
from collections import Counter

def main():
	_ = input()
	frequency = Counter(map(int, input().split()))
	print(max(frequency.values()))
main()


n = int(input().strip(' '))
coins = list(map(int, input().strip(' ').split(' ')))
pkt = [0] * 101
for coin in coins:
	pkt[coin] += 1
print(max(pkt))


n = input()
s = list(map(int, input().split()))
print(max((s.count(x) for x in s)))


input()
l = list(map(int, input().split()))
print(max((l.count(x) for x in range(200))))


n = int(input())
arr = [int(i) for i in input().split()]
x = list(map(lambda x: arr.count(x), arr))
print(max(x))


a = int(input())
b = [int(i) for i in input().split()]
c = [0] * 101
for elem in b:
	c[elem] += 1
print(max(c))


n = int(input())
a = list(map(int, input().split()))
cnt = [0] * 101
for _ in a:
	cnt[_] += 1
print(max(cnt))


n = int(input())
l = [int(x) for x in input().split()]
d = {}
for i in l:
	d[i] = l.count(i)
l2 = list(d.values())
l2.sort(reverse=True)
print(l2[0])


n = int(input())
a = list(map(int, input().split()))
d = {}
for i in a:
	if i in d:
		d[i] = d[i] + 1
	else:
		d[i] = 1
c = max(d.values())
print(c)


n = int(input())
arr = list(map(int, input().split()))
d = dict()
for a in arr:
	if not a in d:
		d[a] = 0
	d[a] += 1
maxn = 0
for a in d:
	maxn = max(maxn, d[a])
print(maxn)


n = int(input())
a = list(map(int, input().split()[:n]))
a.sort()
from itertools import groupby
c = [sum((1 for _ in group)) for (_, group) in groupby(a)]
print(max(c))


import math
n = int(input())
a = list(map(int, input().split()))
b = [0 for i in range(101)]
for i in a:
	b[i] += 1
print(max(b))


import time

def calcMinPock(coinsq, coins):
	minPockets = 0
	maxOcurrence = 0
	for x in coins:
		maxOcurrence = 0
		for y in coins:
			if x == y:
				maxOcurrence += 1
		if minPockets < maxOcurrence:
			minPockets = maxOcurrence
	return minPockets

def solve():
	coinsq = int(input())
	coins = []
	coins = list(map(int, input().split()))
	print(calcMinPock(coinsq, coins))
solve()


n = int(input())
a = list(map(int, input().split())) + [-1]
a.sort()
mx = 0
c = 0
cur = 0
for i in a:
	if i == c:
		cur += 1
	else:
		c = i
		cur = 1
	mx = max(mx, cur)
print(mx)


n = int(input())
x = [int(i) for i in input().split()]
ans = [0] * 101
for i in x:
	ans[i] += 1
print(max(ans))


n = int(input())
l = list(map(int, input().split(' ')))
s = set(l)
temp = 0
cou = 0
for i in s:
	cou = l.count(i)
	if cou >= temp:
		temp = cou
print(temp)


n = int(input())
coins = [int(k) for k in input().split()]
reps = []
for i in coins:
	reps.append(coins.count(i))
print(max(reps))


n = int(input())
from collections import Counter
arr = [int(x) for x in input().split()]
f = Counter(arr)
m = 0
for (k, v) in f.items():
	m = max(m, v)
print(m)


n = int(input())
mas = [int(i) for i in input().split()]
max_count = 1
for i in mas:
	count = mas.count(i)
	if count > max_count:
		max_count = count
print(max_count)


n = int(input())
A = list(map(int, input().split()))
B = [0 for i in range(100)]
for i in A:
	B[i - 1] = B[i - 1] + 1
out = max(B)
print(out)


def pockets():
	coins_num = int(input())
	coins = list(map(int, input().split()))
	poss_pockets = [0 for x in range(101)]
	for coin in coins:
		poss_pockets[coin] += 1
	return max(poss_pockets)
print(pockets())


n = int(input())
x = list(map(int, input().split()))
s = 0
for i in x:
	while x.count(i) > s:
		s += 1
print(s)


x = int(input())
y = list(map(int, input().split()))
s = []
for i in range(x):
	k = 1
	for j in range(i, -1, -1):
		if i == j:
			continue
		if y[i] == y[j]:
			k = k + 1
	s.append(k)
print(max(s))


n = int(input())
ai = list(map(int, input().split()))
s = {}
for i in ai:
	if i not in s:
		s[i] = 1
	else:
		s[i] += 1
print(max(s.values()))


def getMaxOccValue(n, arr):
	maxcount = 0
	for i in arr:
		count = 0
		for j in arr:
			if i == j:
				count += 1
		if count >= maxcount:
			maxcount = count
	return maxcount
n = int(input())
coins = input().split()
coins = [int(x) for x in coins]
ans = getMaxOccValue(n, coins)
print(ans)


a = int(input())
s = [int(x) for x in input().split()]
print(s.count(max(s, key=lambda x: s.count(x))))


def func():
	n = int(input())
	x = [int(i) for i in input().split()]
	k = {}
	m = 0
	for i in x:
		if i in k:
			k[i] += 1
			if m < k[i]:
				m = k[i]
		else:
			k[i] = 1
			if m < k[i]:
				m = k[i]
	return m
print(func())


n = int(input())
l = list(map(int, input().split()))
print(max((l.count(i) for i in l)))


n = int(input())
l = list(map(int, input().split()))
l.sort()
x = 0
p = []
for i in l:
	x = l.count(i)
	p.append(x)
print(max(p))


n = int(input())
l = [int(x) for x in input().split()]
q = []
for i in range(n):
	q.append(l.count(l[i]))
print(max(q))


n = int(input())
a = list(map(int, input().split()))
a.sort()
count = num = 1
for i in range(n - 1):
	if a[i] == a[i + 1]:
		count += 1
		if count > num:
			num = count
	else:
		count = 1
print(num)


m = [list(map(int, input().split())) for _ in range(2)][1]
d = dict()
for i in m:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
m = 0
for i in d:
	m = m if m > d[i] else d[i]
print(max(d.values()))


def do():
	n = int(input())
	dat = list(map(int, input().split()))
	import collections
	c = collections.Counter(dat)
	res = c.most_common(1)[0][1]
	print(res)
do()

def templ():
	from pprint import pprint
	q = int(input())
	for _ in range(q):
		s = input()
		n = int(input())
		(n, k) = map(int, input().split())
		dat = list(map(int, input().split()))
	dat = [1, 2, 3]
	print(' '.join(list(map(str, res))))
	pass
	import math
	math.ceil(1.2)
	math.floor(1.2)
	round(1.2, 3)


from collections import defaultdict as dd
n = int(input())
a = [int(i) for i in input().split(' ')]
d = dd(int)
for i in a:
	d[i] += 1
e = d.values()
print(max(e))


from sys import stdin, stdout
from collections import defaultdict, Counter, deque
n = int(stdin.readline())
l = list(map(int, stdin.readline().split()))
d = dict(Counter(l))
m = 0
for (i, j) in d.items():
	m = max(m, j)
print(m)


num = int(input())
arr = input().split()
dicti = {}
for k in range(0, len(arr)):
	l = int(arr[k])
	if l in dicti.keys():
		dicti[l] += 1
	else:
		dicti[l] = 1
max_val = 0
for key in dicti.keys():
	max_val = max(max_val, dicti[key])
print(max_val)


from collections import Counter

def f(arr):
	cnt = Counter(arr)
	return max(cnt.values())
n = int(input())
arr = [int(i) for i in input().split()]
print(f(arr))


a1 = input()
a2 = input()
a1 = int(a1)
a2 = a2.split(' ')
a2 = [int(i) for i in a2]
a3 = list(set(a2))
a4 = max([a2.count(i) for i in a3])
print(a4)


from collections import Counter
n = int(input())
a = map(int, input().split())
counts = Counter(a)
print(counts.most_common(1)[0][1])


n = int(input())
a = list(map(int, input().split()))
a.sort()
tecmax = 0
tec = 1
num = a[0]
for i in range(1, n):
	if a[i] == num:
		tec += 1
	else:
		tecmax = max(tec, tecmax)
		tec = 1
		num = a[i]
print(max(tec, tecmax))


t = int(input())
arr = [num for num in input().split()]
i = 0
m = 0
while i < t:
	if m < arr.count(arr[i]):
		m = arr.count(arr[i])
	i += arr.count(arr[i])
print(m)


n = int(input())
my_list = list(map(int, input().split()))
m = 0
i = 0
while i < len(my_list):
	c = my_list.count(my_list[i])
	i = i + c
	m = max(m, c)
print(m)


_ = input()
coins = [int(coin) for coin in input().split(' ')]
set_coins = {coin: 0 for coin in coins}
for element in coins:
	set_coins[element] += 1
print(max([v for (k, v) in set_coins.items()]))


n = int(input())
a = list(map(int, input().split()))
num = [0] * 110
mx = 0
for i in a:
	num[i] += 1
	mx = max(mx, num[i])
print(mx)


l = [0] * 101
n = input()
lst = list(map(int, input().split()))
for i in lst:
	l[i] += 1
print(max(l))


c = int(input())
mas = input().split()
counter = {x: 0 for x in mas}
for x in mas:
	counter[x] += 1
print(max(list(counter.values())))


def arr_inp():
	return [int(x) for x in input().split()]
n = int(input())
a = arr_inp()
a.sort()
(count, pre, ma) = (1, a[0], 1)
for i in range(1, n):
	if a[i] == pre:
		count += 1
	else:
		count = 1
		pre = a[i]
	ma = max(count, ma)
print(ma)


n = int(input())
a = list(map(int, input().split()))
from collections import Counter as C
c = C(a)
(v, o) = c.most_common(1)[0]
print(o)


from collections import Counter
n = int(input())
l = list(map(int, input().split()))
a = dict(Counter(l))
print(max(a.values()))


n = int(input())
a = list(map(int, input().split()))
x = []
for i in a:
	x.append(a.count(i))
print(max(x))


from sys import stdin, stdout

def main():
	n = int(stdin.readline())
	a = [int(i) for i in stdin.readline().split()]
	d = dict()
	for i in a:
		d[i] = d.get(i, 0) + 1
	top = d[a[0]]
	for v in d.keys():
		if d[v] > top:
			top = d[v]
	stdout.write(str(top) + '\n')
main()


n = int(input(''))
arr = list(map(int, input().split()))
cnt = [0] * 101
for i in arr:
	cnt[i] += 1
print(max(cnt))


n = int(input())
s = list(map(int, input().split()))
ans = -1
y = set(s)
y = list(s)
for i in y:
	x = s.count(i)
	if x > ans:
		ans = x
print(ans)


n = int(input())
lst = list(map(int, input().split()))
count = []
for i in range(1, 101):
	count.append(lst.count(i))
print(max(count))


n = int(input())
l = list(map(int, input().split()))
d = {}
s = set(l)
for item in l:
	if item in d:
		d[item] += 1
	else:
		d[item] = 1
nmax = -1000009
for item in s:
	nmax = max(d[item], nmax)
print(nmax)


n = int(input())
A = list(map(int, input().split()))
A.sort()
(count, maxi) = (1, 1)
for i in range(len(A) - 1):
	if A[i] == A[i + 1]:
		count += 1
		maxi = max(maxi, count)
	else:
		count = 1
print(maxi)


n = int(input())
l = list(map(int, input().split()))
j = list(set(l))
h = []
for i in range(len(j)):
	h.append(l.count(j[i]))
print(max(h))


import sys

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def rinput():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))
n = iinput()
s = list(map(int, input().split()))
l = list(set(s))
a = []
for i in range(len(l)):
	a.append(s.count(l[i]))
print(max(a))


m = input()
L = [0] * 101
for k in map(int, input().split()):
	L[k] += 1
print(max(L))


n = int(input())
li = list(map(int, input().split()))
b = [0] * 101
for x in li:
	b[x] += 1
print(max(b))


from collections import Counter
coins_count = input()
coins = Counter(input().split())
print(max(coins.values()))


n = int(input())
a = list(map(int, input().split()))
massiv = [0] * 102
for i in range(n):
	massiv[a[i]] += 1
print(max(massiv))


from collections import Counter
a = input()
b = input()
b = b.split()
b = Counter(b)
max_ = 0
for x in b:
	if b[x] > max_:
		max_ = b[x]
print(max_)


n = int(input())
a = list(map(float, input().split(' ')))
print(a.count(int(max(a, key=a.count))))


import sys
n = int(sys.stdin.readline())
l = sys.stdin.readline().strip('\n').split(' ')
l.sort()
count = 1
aux = 1
for j in range(1, n):
	if l[j - 1] == l[j]:
		count += 1
		if count > aux:
			aux = count
		continue
	else:
		count = 1
print(aux)


from collections import Counter
n = int(input())
a = list(map(int, input().split()))
freq = Counter(a)
li = list(freq.values())
print(max(li))


n = int(input(''))
liste = input('').split(' ')
nombre = []
for i in range(len(liste)):
	liste[i] = int(liste[i])
for i in range(max(liste) + 1):
	nombre.append(liste.count(i))
print(max(nombre))


from sys import exit
n = int(input())
s = list(map(int, input().split()))
ans = 0
for i in range(101):
	ans = max(ans, s.count(i))
print(ans)


n = int(input())
min = 0
k = list(map(int, input().split()))
for i in range(n):
	s = k.count(k[i])
	if s > min:
		min = s
print(min)


n = int(input())
coin = [int(i) for i in input().split()]
cost = [0 for i in range(101)]
for i in range(n):
	cost[coin[i]] += 1
print(max(cost))


qwertyuiop = input()
a = input()
a = a.split()
a = [int(k) for k in a]
b = set(a)
most = 0
for k in b:
	if a.count(k) > most:
		most = a.count(k)
print(most)


input()
s = input().split()
print(max([s.count(i) for i in set(s)]))


n = int(input())
l = [*map(int, input().split())]
print(max(map(l.count, set(l))))


n = int(input())
a = list(map(int, input().split()))
c = [0] * 101
for d in a:
	c[d] += 1
print(max(c))


n = int(input())
l = list(map(int, input().split()))
ans = []
for i in l:
	k = l.count(i)
	ans.append(k)
print(max(ans))


n = int(input())
ar = input().split()
f = [0] * 101
for i in range(0, n):
	ar[i] = int(ar[i])
	f[ar[i]] += 1
print(max(f))


n = int(input())
nums = list(map(int, input().split()))
total = 0
for i in range(n):
	if nums.count(nums[i]) > total:
		total = nums.count(nums[i])
print(total)


from collections import *
n = int(input())
a = list(map(int, input().split()))
count = Counter(a)
maxval = max(count.values())
print(maxval)


n = int(input())
l = list(map(int, input().split()))
m = max(l)
ans = []
i = 0
while i <= m:
	ans.append(0)
	i += 1
y = 0
while y < n:
	ans[l[y]] += 1
	y += 1
print(max(ans))


def solve(n, ar):
	ans = 0
	cnt = 1
	ar.sort()
	if n == 1:
		print(1)
		return
	for i in range(1, n):
		if ar[i] == ar[i - 1]:
			cnt += 1
		else:
			ans = max(ans, cnt)
			cnt = 1
	ans = max(ans, cnt)
	print(ans)
n = int(input())
ar = list(map(int, input().split()))
solve(n, ar)


n = int(input())
l = list(map(int, input().split()))
s = set(l)
m = 0
for i in s:
	c = l.count(i)
	if c > m:
		m = c
print(m)


from collections import Counter
a = input()
b = list(map(int, input().split()))
k = Counter(b).values()
k = list(k)
m = max(k)
print(m)


import math as mt

def mostFrequent(arr, n):
	Hash = dict()
	for i in range(n):
		if arr[i] in Hash.keys():
			Hash[arr[i]] += 1
		else:
			Hash[arr[i]] = 1
	max_count = 0
	res = -1
	for i in Hash:
		if max_count < Hash[i]:
			res = i
			max_count = Hash[i]
	return res
n = int(input())
l = list(map(int, input().split()))
m = mostFrequent(l, n)
print(l.count(m))


from sys import *
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
v = list(set(a))
ans = []
for i in v:
	ans.append(a.count(i))
print(max(ans))


n = int(input())
a = list(map(int, input().split()))
b = []
k = 0
n = 0
a = sorted(a)
c = list(set(a))
a = [-1] + a + [-1]
for i in range(len(a) - 1):
	if a[i] == a[i + 1]:
		n += 1
	elif a[i] != a[i + 1]:
		b.append(n + 1)
		n = 0
if len(a) > 1 and len(b) == 0:
	b.append(len(a))
if len(b) > 0:
	print(max(b))
else:
	print(1)


n = int(input(''))
coin = input('')
num = 0
list1 = [int(a) for a in coin.split()]
for i in range(0, n):
	N = 0
	for j in range(i + 1, n):
		if list1[i] == list1[j]:
			N += 1
	if N > num:
		num = N
print(num + 1)


n = int(input())
arr = (int(x) for x in input().split(' '))
l1 = 10000 * [0]
l2 = list()
for x in arr:
	l1[x] = l1[x] + 1
ans = 0
for x in l1:
	ans = max(ans, x)
print(ans)


n = int(input())
coinlist = list(input().split())
pocketlist = []
for pockets in range(n):
	pock = 1
	for coins in range(n):
		if pockets == coins:
			continue
		if coinlist[pockets] == coinlist[coins]:
			pock += 1
	pocketlist.append(pock)
print(max(pocketlist))


a = int(input())
b = list(map(int, input().split()))
b.sort()
c = [0] * 100
point = 0
cur = b[0]
for i in b:
	if i == cur:
		c[point] = c[point] + 1
	else:
		cur = i
		point = point + 1
		c[point] = c[point] + 1
c.sort(reverse=True)
print(c[0])


n = int(input())
arr = list(map(int, input().split()))
d = dict()
cnt = 0
for num in arr:
	if num in d:
		d[num] += 1
	else:
		d[num] = 1
print(max(d.values()))


d = {}
n = int(input())
max = 0
p = input().split()
for i in range(n):
	x = int(p[i])
	d[x] = 0
for i in range(n):
	x = int(p[i])
	d[x] += 1
	if max < d[x]:
		max = d[x]
print(max)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	l = LI()
	l.sort()
	a = l[0]
	c = 1
	mx = 1
	for x in l[1:]:
		if x == a:
			c += 1
		else:
			a = x
			mx = max(mx, c)
			c = 1
	mx = max(mx, c)
	return mx
print(main())


t = int(input())
s = input()
n = [int(s) for s in s.split()]
o = 0
u = 1
for i in range(t):
	o = n.count(n[i])
	if o > u:
		u = o
print(u)


import math as ma
from sys import exit
from decimal import Decimal as dec

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

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

def nu():
	return int(input())
n = nu()
a = li()
f = [0] * 101
p = 0
for i in range(len(a)):
	f[a[i]] += 1
for i in range(101):
	if f[i] == 0:
		continue
	x = f[i] - p
	if x > 0:
		p = p + x
print(p)


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

def countItem(x, list):
	count = 0
	for item in list:
		if x == item:
			count += 1
	return count
answer = 0
for item in a:
	count = countItem(item, a)
	if count > answer:
		answer = count
print(answer)


n = int(input())
l = list(map(int, input().split()))
i = 0
ans = 0
while i < n:
	ans = max(ans, l.count(l[i]))
	i = i + 1
print(ans)


n = input()
list = input().split()
m = 0
for i in list:
	if list.count(i) > m:
		m = list.count(i)
print(m)


n = int(input())
arr = list(map(int, input().split()))
dpar = []
for i in range(101):
	dpar.append(0)
for i in arr:
	dpar[i] += 1
print(max(dpar))


n = input()
n = int(n)
arr = input().split(' ')
for i in range(n):
	arr[i] = int(arr[i])
occurance = 0
for i in range(0, n):
	tempoccurance = 0
	for j in range(0, n):
		if arr[i] == arr[j]:
			tempoccurance = tempoccurance + 1
	if occurance < tempoccurance:
		occurance = tempoccurance
print(occurance)


input()
arr = list(map(int, input().split()))
res = 0
for i in arr:
	res = max(arr.count(i), res)
print(res)


import collections
n = int(input())
a = list(map(int, input().split()))
c = collections.Counter(a)
mxm = 0
for i in c:
	if c[i] > mxm:
		mxm = c[i]
print(mxm)


n = int(input())
l = [int(x) for x in input().split()]
pocket = [0] * 101
for i in range(len(l)):
	pocket[l[i]] += 1
print(max(pocket))


n = int(input())
lst = list(map(int, input().split()))
MaxOccur = max(lst, key=lst.count)
print(lst.count(MaxOccur))


t = int(input())
s = list(map(int, input().split()))
x = max(set(s), key=s.count)
print(s.count(x))


import collections
k = int(input())
n = collections.Counter(map(int, input().split(' ')))
l = []
for i in n:
	l.append(n[i])
print(max(l))


import sys
from collections import Counter
n = int(sys.stdin.readline().rstrip())
cs = sys.stdin.readline().rstrip().split()
cs = [int(c) for c in cs]
count = Counter(cs)
ch = count.most_common(1)
print(ch[0][1])


n = int(input())
l = list(map(int, input().split()))
l.sort()
c = 1
mc = 1
for i in range(len(l) - 1):
	if l[i] == l[i + 1]:
		c += 1
	else:
		c = 1
	if mc < c:
		mc = c
print(mc)


from collections import *
input()
print(max(Counter(input().split()).values()))


n = int(input())
a = [int(x) for x in input().split()]
d = {}
for i in a:
	try:
		d[i] += 1
	except KeyError:
		d[i] = 1
m = -1
for i in d:
	if d[i] > m:
		m = d[i]
print(m)


from collections import Counter

def solve(arr):
	counter = Counter(arr)
	return max(counter.values())

def main():
	n = int(input())
	arr = list(map(int, input().split()))
	print(solve(arr))
main()


n = input()
b = list(map(int, input().split()))
flag = [0 for i in range(110)]
for i in b:
	flag[i] += 1
print(max(flag))


input()
a = input().split()
print(max((a.count(i) for i in a)))


n = int(input())
l = list(map(int, input().split()))
d = {}
for i in l:
	d[i] = l.count(i)
maxim = 0
for i in d:
	maxim = max(d[i], maxim)
print(maxim)


n = int(input())
a = [int(a) for a in input().split()]
b = list()
b.append([])
b[0].append(a[0])
flag = True
for i in range(1, n):
	for j in range(len(b)):
		if a[i] not in b[j]:
			b[j].append(a[i])
			flag = True
			break
		else:
			flag = False
	if flag == False:
		b.append([])
		b[j + 1].append(a[i])
print(len(b))


n = int(input())
l = [int(i) for i in input().split()]
s = set(l)
m = 0
for i in s:
	if m < l.count(i):
		m = l.count(i)
print(m)


n = int(input())
l = list(map(int, input().split()))
d = {}
for i in l:
	if i in d:
		d[i] = d[i] + 1
	else:
		d[i] = 1
l = d.values()
print(max(l))


from collections import Counter
n = int(input())
count = 1
c = list(map(int, input().split()))
while not Counter(c).most_common()[0][1] == 1:
	a = min(c)
	b = max(c)
	d = []
	for i in range(len(c)):
		if c[i] not in d:
			d.append(c[i])
	count += 1
	for i in d:
		c.remove(i)
print(count)


from collections import Counter
noe = int(input())
print(max(Counter([int(x) for x in input().split()]).values()))


b = int(input())
a = input().split()
i = 0
maxi = 0
stre = 0
while i < b - 1:
	j = i + 1
	while j < b:
		if int(a[i]) == int(a[j]):
			stre = stre + 1
		j = j + 1
	if stre > maxi:
		maxi = stre
	stre = 0
	i = i + 1
print(maxi + 1)


n = int(input())
l = dict()
maxx = 0
a = [int(elem) for elem in input().split()]
for i in range(n):
	if a[i] not in l:
		l[a[i]] = 1
		if 1 > maxx:
			maxx = 1
	else:
		l[a[i]] = l[a[i]] + 1
		if l[a[i]] > maxx:
			maxx = l[a[i]]
print(maxx)


t = int(input())
a = list(map(int, input().split()))
r = 0
for item in list(set(a)):
	new = a.count(item)
	if new > r:
		r = new
print(r)


def solve():
	n = int(input())
	a = [0 for i in range(100)]
	n_ = input()
	for i in n_.split(' '):
		a[int(i) - 1] += 1
	return max(a)
ans = solve()
print(ans)


n = int(input())
l = list(map(int, input().split()))
while n == len(l):
	print(l.count(max(l, key=l.count)))
	break


from collections import Counter
n = int(input())
a = [int(x) for x in input().split()]
dic = Counter(a)
m = 0
for item in dic:
	if dic[item] > m:
		m = dic[item]
print(m)


n = int(input())
vals = list(map(int, input().split(' ')))
prihradky = [0] * 101
for i in vals:
	prihradky[i] += 1
print(max(prihradky))


n = int(input())
a = []
l = list(map(int, input().split()))
for x in range(n):
	a.append(l.count(l[x]))
print(max(a))


from collections import defaultdict
input()
arr = [*map(int, input().split())]
c = defaultdict(int)
for a in arr:
	c[a] += 1
print(max(c.values()))


n = int(input())
arr = list(map(int, input().split()))
ans = 1
for e in arr:
	ans = max(ans, arr.count(e))
print(ans)


n = int(input())
u = list(map(int, input().split()))
u.sort()
u.append(10000000)
k = 1
m = 1
for i in range(1, n + 1):
	if u[i] == u[i - 1]:
		k += 1
	else:
		if k > m:
			m = k
		k = 1
print(m)


n = int(input())
li = list(map(int, input().split()))
di = dict()
for j in li:
	if j in di.keys():
		di[j] = di[j] + 1
	else:
		di[j] = 1
maxcount = 0
for h in di.keys():
	if di[h] > maxcount:
		maxcount = di[h]
print(maxcount)


n = int(input())
a = list(map(int, input().split()))
occurence = {}
for i in a:
	if i in occurence:
		occurence[i] += 1
	else:
		occurence[i] = 1
print(max(occurence.values()))


import collections
n = int(input())
numbers = list(map(int, input().split()))
frequencies = collections.Counter(numbers)
print(max(frequencies.values()))


n = int(input())
a = input().split()
ans = 0
for i in a:
	ans = max(ans, a.count(i))
print(ans)


n = int(input())
coins = [int(c) for c in input().split()]
m = 0
for c in set(coins):
	x = coins.count(c)
	if x > m:
		m = x
print(m)


n = int(input())
a = [int(s) for s in input().split()]
a.sort()
count = 1
max = 1
for i in range(len(a) - 1):
	if a[i] == a[i + 1]:
		count += 1
	else:
		if count > max:
			max = count
		count = 1
if count > max:
	print(count)
else:
	print(max)


from collections import defaultdict

def solve(l):
	d = defaultdict(int)
	m = 0
	for i in l:
		d[i] += 1
		m = max(m, d[i])
	return m
input()
l = map(int, input().split())
print(solve(l))


n = int(input())
m = list(map(int, input().split()))
a = 0
maxi = 0
for i in m:
	a = m.count(i)
	if a > maxi:
		maxi = a
print(maxi)


input()
a = list(map(int, input().split()))
m = 0
d = {}
for item in a:
	d[item] = d.get(item, 0) + 1
	m = max(m, d[item])
print(m)


n = int(input())
arr = []
for i in range(101):
	arr.append(0)
x = input()
x = x.split()
for i in range(n):
	x[i] = int(x[i])
	arr[x[i]] += 1
max = arr[0]
for i in range(101):
	if max < arr[i]:
		max = arr[i]
print(max)


from collections import Counter
n = int(input())
a = list(map(int, input().split()))
d = Counter(a)
m = max(d.values())
print(m)


n = int(input())
inp = input().split()
arr = []
for i in inp:
	arr.append(int(i))
counts = dict()
for i in arr:
	counts[i] = counts.get(i, 0) + 1
x = max(counts.keys(), key=lambda k: counts[k])
print(counts[x])


n = int(input())
array = [int(x) for x in input().split(' ')]
repetidos = {}
for elem in array:
	if not elem in repetidos:
		repetidos[elem] = 1
	else:
		repetidos[elem] += 1
maximo = max(repetidos.values())
print(maximo)


x = int(input())
l = list(map(int, input().split()))
t = set(l)
max = l.count(0)
for i in t:
	if l.count(i) > max:
		max = l.count(i)
print(max)


a = int(input())
b = input()
c = b.split()
d = list(map(int, c))
max_repition = 0
for r in d:
	n = 0
	for i in d:
		if r == i:
			n = n + 1
			if n > max_repition:
				max_repition = n
print(max_repition)


n = int(input())
a = [int(x) for x in input().split(' ')]
max_count = 1
for item in a:
	count = a.count(item)
	if count > max_count:
		max_count = count
	a = [value for value in a if value != item]
print(max_count)


n = int(input())
lst = list(map(int, input().split()))
dict = {}
for i in lst:
	if i in dict:
		dict[i] += 1
	else:
		dict[i] = 1
max = 0
for i in dict.values():
	if i > max:
		max = i
print(max)


n = int(input())
a = list(map(int, input().split()))
print(max((a.count(v) for v in a)))


n = int(input())
m = list()
c = int(1)
a = list(map(int, input().split()))
a.sort()
for i in range(n - 1):
	if a[i] == a[i + 1]:
		c += 1
	else:
		m.append(c)
		c = 1
m.append(c)
m.sort()
print(m[len(m) - 1])


n = int(input())
l = list(sorted(map(int, input().split())))
c = 1
max1 = 1
for i in range(1, n):
	if l[i] == l[i - 1]:
		c = c + 1
	else:
		c = 1
	max1 = max(max1, c)
print(max1)


x = int(input())
coins = input()
coins = coins.split()
cd = {x: coins.count(x) for x in set(coins)}
max = 0
for key in cd:
	if cd[key] > max:
		max = cd[key]
print(max)


n = int(input())
num = input()
a = []

def get_the_data(count, num, arr):
	for i in range(0, len(num)):
		if num[i] == ' ':
			arr.append(int(num[count:i]))
			count = i + 1
		elif i == len(num) - 1:
			arr.append(int(num[count:len(num)]))
	return arr
arr = get_the_data(0, num, a)
arr.sort()
max_num = 1
count = 1
for i in range(0, len(arr) - 1):
	if arr[i] != arr[i + 1]:
		if count > max_num:
			max_num = count
		count = 1
	else:
		count += 1
		if i == len(arr) - 2:
			if count > max_num:
				max_num = count
print(max_num)


n = int(input())
a = list(map(int, input().split()))
dict = {}
for i in a:
	if i in dict:
		dict[i] += 1
	else:
		dict[i] = 1
ans = max(dict.values())
print(ans)


n = int(input())
arr = input().split(' ')
d = {}
for i in range(n):
	arr[i] = int(arr[i])
	if arr[i] in d.keys():
		d[arr[i]] += 1
	else:
		d[arr[i]] = 1
m = 0
for elem in d.values():
	if elem > m:
		m = elem
print(m)


x = int(input())
list2 = []
list1 = list(map(int, input().split()))
for i in list1:
	list2.append(list1.count(i))
print(max(list2))


a = int(input())
li = sorted(list(map(int, input().split())))
li2 = []
for i in range(a):
	li2.append(li.count(li[i]))
print(max(li2))


input()
l = list(map(int, input().split()))
print(max([l.count(now) for now in l]))


n = int(input())
list = input().split(' ')
m = []
for i in range(0, n):
	x = list.count(list[0])
	m.append(x)
	list.remove(list[0])
m.sort()
print(m[-1])


def coins(n, ls):
	l = []
	for i in range(n):
		l.append(ls.count(ls[i]))
	return max(l)
n = int(input())
ls = [int(i) for i in input().split()]
print(coins(n, ls))


from collections import defaultdict

def read_int():
	return list(map(int, input().split()))
n = int(input())
arr = read_int()
m = defaultdict(int)
for a in arr:
	m[a] += 1
print(max(m.values()))


n = int(input())
ar = [0] * 101
fr = [int(p) for p in input().split()]
for i in range(n):
	x = fr[i]
	ar[x] += 1
ar.sort()
print(ar[100])


n = int(input())
a = list(map(int, input().split()))
cnt = [0] * 105
for i in range(0, n):
	cnt[a[i]] += 1
res = 0
for i in range(0, n):
	res = max(res, cnt[a[i]])
print(res)


n = int(input())
A = list(map(int, input().split()))
Max = 1
for i in set(A):
	Max = max(Max, A.count(i))
print(Max)


import sys
import collections

def readArray(type=int):
	line = input()
	return [type(x) for x in line.split()]

def solve():
	n = input()
	ar = readArray()
	freq = collections.defaultdict(int)
	for x in ar:
		freq[x] += 1
	print(max(freq.values()))
solve()


n = int(input())
a = [int(x) for x in input().split()][:n]
pocket = 1
s = set()
s.update(a)
new = [a.count(i) for i in s]
print(max(new))


N = int(input())
S = list(map(int, input().split()))
count = 0
for i in range(1, 101):
	excount = 0
	for j in range(len(S)):
		if S[j] == i:
			excount += 1
	if count < excount:
		count = excount
print(count)


n = int(input())
L = list(map(int, input().split()))
C = [0 for i in range(100)]
for i in L:
	C[i - 1] = C[i - 1] + 1
print(max(C))


a = int(input())
s = list(map(int, input().split()))
m = s.count(s[0])
for i in s:
	if s.count(i) > m:
		m = s.count(i)
print(m)


n = int(input())
a = [int(x) for x in input().split()]
res = 0
d = set(a)
res = max([a.count(x) for x in d])
print(res)


n = int(input())
n = input()
coins = []
for x in n.split(' '):
	coins.append(int(x))
coins = sorted(coins)
poc = []
dup = []
add = 0
temp = 0
for x in coins:
	if int(x) not in poc:
		poc.append(int(x))
		if add > temp:
			temp = temp + abs(temp - add)
			add = 0
		else:
			add = 0
	elif int(x) not in dup:
		dup.append(int(x))
	else:
		add += 1
if len(dup) >= 1:
	if add > 0:
		if add > temp:
			temp = temp + abs(temp - add)
			print(1 + 1 + temp)
		else:
			print(1 + 1 + temp)
	else:
		print(1 + 1 + temp)
else:
	print(1)


n = int(input())
counting = []
array = input().split()
array = [int(array[i]) for i in range(len(array))]
new_set = set(array)
for com in new_set:
	just = array.count(com)
	counting.append(just)
print(max(counting))


def countX(a, x):
	return a.count(x)
size = int(input())
a = []
a = [int(x) for x in input().split()]
c = 0
for x in a:
	c = max(countX(a, x), c)
print(c)


import sys
num = int(sys.stdin.readline())
arr = []
for line in sys.stdin:
	arr = line.split()
count = dict()
for i in arr:
	if i in count:
		count[i] += 1
	else:
		count[i] = 1
mm = 0
for x in count.values():
	if x > mm:
		mm = x
print(mm)


import collections
max = 0
s = input()
a = input().split()
a = [int(i) for i in a]
c = collections.Counter(a)
for i in c:
	if c[i] >= max:
		max = c[i]
print(max)


from sys import stdin, stdout
from collections import Counter, deque, OrderedDict

def si():
	return str(stdin.readline())

def ii():
	return int(input())

def mi():
	return map(int, stdin.readline().split())

def li():
	return [int(i) for i in input().split()]

def debug(x):
	return stdout.write(str(x))

def mul(list):
	return eval('*'.join((str(item) for item in list)))

def max_heapify(A, i):
	left = 2 * i + 1
	right = 2 * i + 2
	largest = i
	if left < len(A) and A[left] > A[largest]:
		largest = left
	if right < len(A) and A[right] > A[largest]:
		largest = right
	if largest != i:
		(A[i], A[largest]) = (A[largest], A[i])
		max_heapify(A, largest)

def build_max_heap(A):
	for i in range(len(A) // 2, -1, -1):
		max_heapify(A, i)

def main():
	t = ii()
	arr = li()
	d = Counter(arr)
	m = d[0]
	for i in d:
		if d[i] > m:
			m = d[i]
	print(m)
main()


from collections import defaultdict
occurences = defaultdict(int)
n = int(input())
for i in input().split(' '):
	occurences[i] += 1
print(max((value for (_, value) in occurences.items())))


from collections import Counter
y = int(input())
x = list(map(int, input().split()))
print(x.count(Counter(x).most_common(1)[0][0]))


from sys import stdin, stdout
n = int(input())
li = list(map(int, stdin.readline().split()))
s = set(li)
maxy = 0
for i in s:
	temp = li.count(i)
	if maxy < temp:
		maxy = temp
print(maxy)


from collections import Counter
t = int(input().strip())
l = [int(x) for x in input().strip().split(' ')]
w = Counter(l)
print(max(w.values()))


from collections import Counter
n = int(input())
a = Counter(map(int, input().split()))
print(max(a.values()))


n = int(input())
a = list(map(int, input().split()))
s = set(a)
m = 1
for i in s:
	if a.count(i) > m:
		m = a.count(i)
print(m)


n = int(input())
a = list(map(int, input().split()))
a.sort()
c = 1
ans = c
for i in range(n - 1):
	if a[i] == a[i + 1]:
		c += 1
	else:
		if c > ans:
			ans = c
		c = 1
if c > ans:
	ans = c
print(ans)


n = int(input())
a = [int(i) for i in input().split()]
b = 0
hue = []
for i in range(len(a)):
	for j in range(i + 1, len(a)):
		if a[i] <= a[j]:
			(a[i], a[j]) = (a[j], a[i])
for i in range(len(a)):
	if i == len(a) - 1:
		break
	elif a[i] == a[i + 1]:
		b += 1
	elif a[i] != a[i + 1]:
		b = 0
	hue += [b]
if n == 1:
	print(1)
else:
	print(max(hue) + 1)


n = int(input())
list = input().split(' ')
for i in range(len(list)):
	list[i] = int(list[i])
list = sorted(list)
currentFreq = 1
currentMaxFreq = 1
for i in range(1, n):
	if list[i] == list[i - 1]:
		currentFreq += 1
	else:
		currentFreq = 1
	if currentFreq > currentMaxFreq:
		currentMaxFreq = currentFreq
print(currentMaxFreq)


a = int(input())
b = list(map(int, input().split()))
lis = [b.count(i) for i in b]
print(max(lis))


from itertools import groupby
n = input()
a = list(map(int, input().split()))
l = [len(list(group)) for (key, group) in groupby(sorted(a))]
print(max(l))


nCoins = int(input())
list = [int(x) for x in input().split()]
list.sort()
maxa = 0
apperance = 1
if nCoins > 1:
	for key in range(nCoins - 1):
		if list[key + 1] == list[key]:
			apperance += 1
			maxa = max(maxa, apperance)
		else:
			maxa = max(maxa, apperance)
			apperance = 1
else:
	maxa = 1
print(maxa)


try:
	n = int(input())
	l = list(map(int, input().split()))
	ans = 0
	for i in l:
		c = l.count(i)
		ans = max(ans, c)
	print(ans)
except:
	pass


n = int(input())
a = list(map(int, input().rstrip().split()))
print(max([a.count(i) for i in a]))


n = int(input())
a = list(map(int, input().split()))
b = set(a)
maxi = 0
for i in b:
	maxi = max(a.count(i), maxi)
print(maxi)


a = int(input())
l = sorted(list(input().split()))
f = 0
c = 1
c1 = 1
for i in range(a - 1):
	if l[i] == l[i + 1] and f == 0:
		c += 1
	elif l[i] == l[i + 1] and f == 1:
		c1 += 1
	elif c1 >= c:
		c = 1
		f = 0
	elif c > c1:
		c1 = 1
		f = 1
if c1 > c:
	print(c1)
else:
	print(c)


inp = input
li = list
iinp = lambda : int(inp())
ent = lambda : map(int, inp().split())
lient = lambda : [int(i) for i in inp().split()]
li0 = lambda x: [0 for i in range(x)]
stent = lambda : [i for i in inp()]
from collections import Counter
n = iinp()
monedas = lient()
ma = Counter(monedas)
res = max(ma.values())
print(res)


input()
li = [int(x) for x in input().split(' ')]
s = set(li)
ans = []
for i in s:
	ans.append(li.count(i))
print(max(ans))


n = int(input())
lst = list(map(int, input().split()))
dict1 = {}
for i in range(len(lst)):
	if lst[i] not in dict1:
		dict1.update({lst[i]: 1})
	else:
		temp = dict1[lst[i]]
		dict1.update({lst[i]: temp + 1})
print(max(dict1.values()))


n = int(input())
a = [int(x) for x in input().split()]
b = [0] * 100
k = 0
for i in range(n):
	b[a[i] - 1] += 1
for i in range(100):
	if k < b[i]:
		k = b[i]
print(k)


n = int(input())
A = list(map(int, input().split()))
count = [0 for _ in range(100 + 1)]
for a in A:
	count[a] += 1
print(max(count))


n = int(input())
a = [int(x) for x in input().split()]
b = set(a)
maximum = 0
for i in b:
	if a.count(i) > maximum:
		maximum = a.count(i)
print(maximum)


from collections import *
input()
print(max(Counter(map(int, input().split())).values()))


n = int(input())
a = sorted([int(x) for x in input().split()])
count = 0
z = 1
for i in range(len(a)):
	z = a.count(a[i])
	if count <= z:
		count = z
print(count)


n = int(input())
a = [int(i) for i in input().split()]
maxi = -2
for x in range(len(a)):
	c = a.count(a[x])
	if c > maxi:
		maxi = c
print(maxi)


n = int(input())
arr = input().split()
ans = 1
for x in arr:
	ans = max(ans, arr.count(x))
print(ans)


from collections import Counter as c
n = int(input())
x = c(list(map(int, input().split()))).values()
print(max(x))


from collections import Counter
from sys import stdin, stdout
input = lambda : stdin.readline().rstrip()
write = stdout.write

def main():
	N = int(input())
	A = tuple(map(int, input().split()))
	cnt = Counter(A)
	topn = cnt.most_common()
	print(topn[0][1])
main()


d = dict()
a = int(input())
a1 = input()
l1 = list(map(int, a1.split()))
for i in range(a):
	if l1[i] not in d:
		d[l1[i]] = 1
	else:
		d[l1[i]] += 1
z = max(d.values())
print(z)


n = int(input())
m = list(map(int, input().split()))
b = []
for i in range(100):
	b.append(0)
for i in range(n):
	b[m[i] - 1] += 1
print(max(b))


import time
n = int(input())
a = [int(i) for i in input().split()]
start = time.time()
c = [0 for i in range(100)]
for i in range(n):
	c[a[i] - 1] += 1
print(max(c))
finish = time.time()


t = int(input())
l = [int(x) for x in input().split()]
s = set(l)
p = [l.count(i) for i in s]
print(max(p))


n = int(input())
l = [int(i) for i in input().split()]
from collections import Counter as C
s = C(l)
max = -1
for i in s:
	if s[i] > max:
		max = s[i]
print(max)


c = int(input())
a = list(map(int, input().split()))
m = 1
for i in range(0, c - 1):
	n = 1
	for j in range(i + 1, c):
		if a[i] == a[j]:
			n = n + 1
	if n > m:
		m = n
print(m)


n = int(input())
a = [int(item) for item in input().split()]
occ = [0] * 101
m = -float('inf')
for i in range(n):
	occ[a[i]] += 1
	m = max(m, occ[a[i]])
print(m)


n = int(input())
a = [int(i) for i in input().split()]
x = [0] * 1010
for value in a:
	x[value] += 1
ans = max(x)
print(ans)


n = int(input())
l = list(map(int, input().split()))
f = []
for i in range(101):
	x = l.count(i)
	f.append(x)
y = max(f)
print(y)


n = int(input())
a = list(map(int, input().split()))
fre = {}
mx = 0
for x in a:
	if x in fre:
		fre[x] += 1
	else:
		fre[x] = 1
	mx = max(mx, fre[x])
print(mx)


n = int(input())
x = list(map(int, input().split()))
x.sort()
(cur_max, cur_min) = (1, 1)
for i in range(1, n):
	if x[i] == x[i - 1]:
		cur_min += 1
	else:
		if cur_min > cur_max:
			cur_max = cur_min
		cur_min = 1
print(max(cur_max, cur_min))


from collections import Counter
n = int(input())
c = Counter(list(map(int, input().split())))
print(c.most_common()[0][1])


def a():
	n = int(input())
	arr = [int(i) for i in input().split()]
	dic = [0] * 101
	for i in arr:
		dic[i] += 1
	print(max(dic))
a()


n = int(input())
data = [int(i) for i in input().split(' ')]
freq = {x: data.count(x) for x in data}
print(max(freq.values()))


n = int(input())
a = list(map(int, input().split()))
f = [0] * 1000
for i in a:
	f[i] += 1
m = max(f)
print(m)


t = int(input())
l1 = []
x = input()
l1 = x.split()
ans = 1
for i in l1:
	m = l1.count(i)
	if int(m) > ans:
		ans = int(m)
print(ans)


from collections import Counter
count = int(input())
a = [int(x) for x in input().split()]
c = Counter(a)
maximum = max(c.values())
print(maximum)


n = int(input())
list = [int(item) for item in input().split()]
if n == 1:
	print(1)
else:
	list.sort()
	prev = list[0]
	sizes = [1]
	cnt = 1
	for i in range(1, n):
		if list[i] == prev:
			cnt += 1
		else:
			sizes.append(cnt)
			cnt = 1
		prev = list[i]
	sizes.append(cnt)
	print(max(sizes))


from collections import Counter

def main():
	n = input()
	print(max(Counter([int(i) for i in input().split()]).values()))
main()


n = int(input())
count = 0
z = 1
ar = sorted(list(map(int, input().split())))
for i in range(len(ar) - 1):
	if ar[i + 1] == ar[i]:
		count += 1
	else:
		z = max(z, count + 1)
		count = 0
print(max(count + 1, z))


n = int(input())
z = list(input().split())
m = 0
for i in range(n):
	if z.count(z[i]) >= m:
		m = z.count(z[i])
print(m)


n = int(input())
l = list(map(int, input().split()))
s = set(l)
count1 = 0
for i in s:
	if l.count(i) > count1:
		count1 = l.count(i)
print(count1)


n = int(input())
a = sorted(list(map(int, input().split())))
solution = 1
count = 1
last = a[0]
for i in a[1:]:
	if last == i:
		count += 1
		solution = max(solution, count)
	else:
		count = 1
	last = i
print(solution)


from math import *
n = int(input())
aa = input().split()
b = [0] * 101
for i in aa:
	j = int(i)
	b[j] += 1
print(max(b))


n = int(input())
a = [int(x) for x in input().split()]
kol = 1
dl = 1
a.sort()
for i in range(1, n):
	if a[i] == a[i - 1]:
		dl += 1
	else:
		dl = 1
	kol = max(kol, dl)
print(kol)


def calc(a):
	assert len(a) > 0
	a.sort()
	counters = list()
	cnt = 1
	value = a[0]
	for item in a[1:]:
		if item == value:
			cnt += 1
		else:
			counters.append(cnt)
			value = item
			cnt = 1
	counters.append(cnt)
	return max(counters)

def get_ints():
	return [int(n) for n in input().split()]

def get_floats():
	return [float(n) for n in input().split()]
a = get_ints()
assert len(a) == 1
n = a[0]
a = get_ints()
assert len(a) == n
res = calc(a)
print(res)


n = int(input())
tab = list(map(int, input().split()))
test = []
for i in tab:
	test.append(tab.count(i))
test.sort()
print(test[-1])


n = int(input())
arr = list(map(int, input().split()))
ct = [0] * 200
for i in range(n):
	ct[arr[i]] += 1
print(max(ct))


n = int(input())
a = input().split()
b = []
for i in range(len(a)):
	b.append(int(a[i]))
c = []
if n >= 2:
	for i in range(len(a)):
		c.append(b.count(b[i]))
	d = max(c)
	print(d)
if n == 1:
	print(int(1))


n = int(input())
arr = list(map(int, input().split(' ')))
arr.sort()
min = 0
for i in range(n):
	count = 1
	for j in range(i + 1, n):
		if arr[i] == arr[j]:
			count = count + 1
	if count > min:
		min = count
print(min)


def solve(sequence):
	return max([sequence.count(c) for c in set(sequence)])

def main():
	_ = int(input().strip())
	sequence = [int(x) for x in input().strip().split()]
	result = solve(sequence)
	print(result)
main()


n = int(input())
a = input().split()
tmp = [0 for i in range(101)]
for i in a:
	tmp[int(i)] = tmp[int(i)] + 1
max = 0
for i in tmp:
	if i > max:
		max = i
print(max)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue
from decimal import *

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)

def pop_count(x):
	x = x - (x >> 1 & 6148914691236517205)
	x = (x & 3689348814741910323) + (x >> 2 & 3689348814741910323)
	x = x + (x >> 4) & 1085102592571150095
	x = x + (x >> 8)
	x = x + (x >> 16)
	x = x + (x >> 32)
	return x & 127
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	N = Scanner.int()
	M = Counter(Scanner.map_int())
	print(max(M.values()))
main()


n = int(input())
l = [0] * 110
j = input().split(' ')
for i in j:
	l[int(i)] += 1
print(max(l))


n = int(input())
coins = [int(c) for c in input().split()]
ans = 0
for c in coins:
	ans = max(ans, sorted(coins).count(c))
print(ans)


a = int(input())
b = list(map(int, input().split()))
dict = {}
point1 = 0
point2 = b[0]
for k in b:
	if k not in dict:
		dict[k] = 1
	else:
		dict[k] += 1
	if dict[k] > point1:
		point1 = dict[k]
		point2 = k
	first = k
print(point1)


a = {}
m = 0
n = int(input())
for j in input().split():
	a[j] = a.setdefault(j, 0) + 1
	if a[j] > m:
		m = a[j]
print(m)


def main():
	ncoins = int(input())
	arr = input().split()
	values = [int(k) for k in arr]
	values.sort()
	npockets = 1
	ind = 0
	while ind < ncoins:
		count = 1
		curr = values[ind]
		while ind + count < ncoins and values[ind + count] == curr:
			count += 1
		npockets = max(npockets, count)
		ind += 1
	print(npockets)
main()


n = int(input())
b = [0 for i in range(101)]
st = [int(i) for i in input().split()]
for i in range(n):
	b[st[i]] += 1
maxi = b[0]
for i in range(101):
	if b[i] > maxi:
		maxi = b[i]
print(maxi)


n = int(input())
A = input().split()
B = list(set(A))
C = []
for i in range(len(B)):
	C.append(A.count(B[i]))
print(max(C))


n = int(input())
array = list(map(int, input().split()))
d = {}
for e in array:
	if d.get(e):
		d[e] += 1
	else:
		d[e] = 1
m = 0
for e in d.values():
	m = max(m, e)
print(m)


n = int(input())
l = list(map(int, input().split()))
l.sort()
c = 1
counter = []
if n == 1:
	print(1)
else:
	for i in range(1, n):
		if l[i] == l[i - 1]:
			c += 1
		else:
			counter.append(c)
			c = 1
		if i == n - 1:
			counter.append(c)
	print(max(counter))


def pockets(arr):
	di = {}
	for i in arr:
		if i in di:
			di[i] += 1
		else:
			di[i] = 1
	big = 0
	for i in di:
		big = max(di[i], big)
	return big
n = int(input())
arr = list(map(int, input().rstrip().split()))
print(pockets(arr))


a = int(input())
b = input()
c = [int(x) for x in b.split()]
c.sort()
counter = 1
countermax = 1
for i in range(1, a):
	if c[i] == c[i - 1]:
		counter += 1
	else:
		counter = 1
	if counter > countermax:
		countermax = counter
print(countermax)


n = int(input())
a = [int(i) for i in input().split()]
s = 0
for i in a:
	if a.count(i) > s:
		s = a.count(i)
print(s)


import math
import bisect
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from collections import Counter
I = lambda : int(input())
tup = lambda : map(int, input().split())
lst = lambda : list(map(int, input().split()))
t = 1
while t:
	n = I()
	arr = lst()
	di = [0 for i in range(101)]
	for i in range(n):
		di[arr[i]] = 1 + di[arr[i]]
	print(max(di))
	t -= 1


n = int(input())
k = list(map(int, input().strip().split()[:n]))
d = {}
l = []
for x in k:
	if len(k) == 1:
		print(1)
		p = True
		break
	elif x in d:
		d[x] += 1
		p = False
		l.append(d[x])
	else:
		d[x] = 1
		p = False
		l.append(d[x])
if p == False:
	print(max(l))


n = int(input())
num = list(map(int, input().split()))
ans = -1
for i in range(n):
	if num.count(num[i]) > ans:
		ans = num.count(num[i])
print(ans)


n = int(input())
a = list(map(int, input().split()))
from collections import Counter
d = Counter(a)
print(max((d[i] for i in d)))


n = int(input())
values = list((int(x) for x in input().split()))
count = 0
for x in values:
	y = values.count(x)
	if y > count:
		count = y
	else:
		continue
print(count)


import math
st = ''

def func(n, l1):
	l = [0 for _ in range(100)]
	for i in l1:
		l[i - 1] += 1
	return max(l)
for _ in range(1):
	n = int(input())
	l1 = list(map(int, input().split()))
	st += str(func(n, l1)) + '\n'
print(st)


n = int(input())
a = list(map(int, input().split()))
c = 1
for i in a:
	if a.count(i) > c:
		c = a.count(i)
print(c)


import collections
t = int(input())
a = [int(x) for x in input().split()]
d = collections.Counter(a)
print(max(list(d.values())))


n = int(input())
s = list(map(int, input().strip().split()))[:n]
a = {}
c = 0
for i in s:
	if i in a:
		a[i] += 1
	else:
		a[i] = 1
for i in a:
	c = max(c, a[i])
print(c)


n = int(input())
ls = [int(i) for i in input().split()]
ls.sort()
mx = 0
while len(ls):
	val = ls.count(ls[0])
	if val > mx:
		mx = val
	for i in range(val):
		ls.remove(ls[0])
print(mx)


def main():
	n = int(input())
	a = list(map(int, input().split()))
	a.sort()
	x = 0
	for i in set(a):
		x = max(a.count(i), x)
	print(x)
	return 0
main()


t = int(input())
l = [int(x) for x in input().strip().split()]
x = dict()
for i in l:
	if i not in x.keys():
		x[i] = 1
	else:
		x[i] = x[i] + 1
mx = 0
for i in x.keys():
	mx = max(mx, x[i])
print(mx)


n = int(input())
r = []
w = []
s = input()
l = s.split()
l = [int(i) for i in l]
for i in l:
	r.append(l.count(i))
print(max(r))


n = int(input())
a = list(map(int, input().split()))
x = []
g = [1]
for i in a:
	if i not in x:
		c = a.count(i)
		if c > 1:
			g.append(c)
print(max(g))


x = int(input())
y = list(map(int, input().split()))
z = []
for i in range(x):
	z.append(y.count(y[i]))
print(max(z))


n = int(input())
m = list(map(int, input().split()))
count = 0
set_m = set(m)
for item in set_m:
	if m.count(item) > count:
		count = m.count(item)
print(count)


n = int(input())
l = [int(x) for x in input().split()]
arr = [0] * 105
for xx in l:
	arr[xx] += 1
print(max(arr))


mmmmmm = int(input())
a = input() + ' '
(A, b) = ([], '')
for j in range(len(a)):
	if a[j] == ' ':
		A.append(int(b))
		b = ''
	else:
		b += a[j]
g = 0
for i in A:
	t = 0
	for j in A:
		if i == j:
			t += 1
	if t > g:
		g = t
print(g)


_ = input()
coins = list(map(int, input().split()))
occ = dict()
m = 0
for c in coins:
	if c in occ:
		occ[c] += 1
	else:
		occ[c] = 1
	m = max(m, occ[c])
print(m)


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
from collections import Counter
n = qi()
print(Counter(qs()).most_common(1)[0][1])


from math import *
from fractions import gcd
import sys
from audioop import reverse

def main():
	n = int(input())
	x = input()
	x = x.split(' ')
	a = []
	i = 1
	while i <= 102:
		a.append(0)
		i += 1
	for c in x:
		a[int(c)] += 1
	ans = -10000000
	for c in a:
		if c > ans:
			ans = c
	print(ans)
main()


n = int(input())
l = list(map(int, input().split()))
l.sort()
maxx = 1
cur = 1
for i in range(n - 1):
	if l[i] == l[i + 1]:
		cur += 1
		if cur > maxx:
			maxx = cur
	else:
		cur = 1
print(maxx)


n = int(input())
voc = list(map(int, input().split()))
dup = []
for i in voc:
	dup.append(voc.count(i))
print(max(dup))


from collections import Counter
input()
print(Counter(input().split()).most_common(1)[0][1])


n = int(input())
l = [int(x) for x in input().split()]
s = set(l)
ans = max([l.count(x) for x in s])
print(ans)


input()
coins = [0] * 100
for c in input().split():
	coins[int(c) - 1] += 1
print(max(coins))


n = int(input())
list = [int(i) for i in input().split()]
large = 0
for i in range(1, 101):
	if large < list.count(i):
		large = list.count(i)
print(large)


def function1():
	garbage = str(input())
	line2 = str(input()).split(' ')
	line2 = [int(x) for x in line2]
	counter = dict()
	for number in line2:
		if number in counter:
			counter[number] += 1
		else:
			counter[number] = 1
	max_freq = 0
	for number in counter:
		max_freq = max(max_freq, counter[number])
	return max_freq
print(function1())


n = int(input())
a = list(map(int, input().split()))
b = [0] * 200
for i in range(n):
	b[a[i]] += 1
print(max(b))


n = int(input())
coins = [int(i) for i in input().split()]
print(max((coins.count(i) for i in coins)))


import os
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return s[:len(s) - 1]

def invr():
	return map(int, input().split())
n = inp()
a = inlt()
ans = 0
for x in a:
	ans = max(ans, a.count(x))
print(ans)


T = int(input())
numbers = [int(s) for s in input().split(' ')]
maxi = 0
for i in range(0, len(numbers)):
	lol = numbers.count(numbers[i])
	if lol > maxi:
		maxi = lol
print(maxi)


n = int(input())
li = [int(x) for x in input().split()]
m = 0
for i in range(n):
	if li.count(li[i]) > m:
		m = li.count(li[i])
print(m)


n = int(input())
l = [int(x) for x in input().split(' ')]
a = 0
f = {}
for i in l:
	if i in f:
		f[i] += 1
	else:
		f[i] = 1
for (key, value) in f.items():
	if value > a:
		a = value
print(a)


def main():
	n = int(input())
	arr = list(map(int, input().split(' ')))
	print(max([arr.count(coin) for coin in arr if arr.count(coin) > 1], default=1))
main()


n = int(input())
a = list(map(int, input().split()))
x = [0] * 100
for i in range(len(a)):
	x[a[i] - 1] += 1
print(max(x))


n = input()
l = list(map(int, input().split()))
s = set(l)
ans = 0
for i in s:
	ans = max(ans, l.count(i))
print(ans)


n = int(input())
a = list(map(int, input().split()))
b = set(a)
r = 1
for i in b:
	r = max(r, a.count(i))
print(r)


k = int(input())
a = list(map(int, input().split()))
b = {}
for i in a:
	if i in b:
		b[i] += 1
	else:
		b[i] = 1
c = 0
for i in b.values():
	if c < i:
		c = i
print(c)


n = input()
l = input().split()
l = [int(n) for n in l]
p = []
for n in range(100):
	p.append(0)
for n in l:
	p[n - 1] += 1
ans = max(p)
print(ans)


n = int(input())
ar = list(map(int, input().split()))
count = [0] * 101
M = 1
for i in ar:
	count[i] += 1
	M = max(M, count[i])
print(M)


def main():
	rd = lambda : list(map(int, input().split()))
	n = int(input())
	arr = rd()
	h = [0] * 1000
	for item in arr:
		h[item] += 1
	print(max(h))

def __starting_point():
	main()
__starting_point()


n = int(input())
l = list(map(int, input().split()))
d = {}
for i in l:
	d[i] = d.get(i, 0) + 1
l1 = list(d.values())
print(max(l1))


input()

def returnMinimumPockets(coins):
	amount = [0] * 101
	for coin in coins:
		amount[int(coin)] += 1
	return max(amount)
print(returnMinimumPockets(input().split(' ')))


input()
a = [*map(int, input().split())]
print(max((a.count(x) for x in a)))


import sys
lines = [line.strip() for line in sys.stdin.readlines()]
coins = map(int, lines[1].split(' '))
freq = {}
for coin in coins:
	if coin in freq:
		freq[coin] += 1
	else:
		freq[coin] = 1
print(max(freq.values()))


input()
x = [int(i) for i in input().split()]
y = [x.count(i) for i in x]
print(max(y))


n = int(input())
a = sorted(list(map(int, input().split())))
m = sorted(list(set(a)))
pok = []
while len(a) != 0:
	s = []
	for i in range(len(m)):
		if a.count(m[i]) != 0:
			s.append(m[i])
			a.remove(m[i])
	pok.append(s)
print(len(pok))


n = int(input().strip())
a = list(map(int, input().strip().split()))
max_v = 0
d = {}
for i in a:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
	if d[i] > max_v:
		max_v = d[i]
print(max_v)


import sys, os
from io import BytesIO, IOBase
import collections, itertools, bisect, heapq, math, string
from decimal import *
BUFSIZE = 8192
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')

def main():
	n = int(input())
	a = list(map(int, input().split()))
	d = collections.Counter(a)
	ans = 0
	for k in d.keys():
		ans = max(ans, d[k])
	print(ans)
main()


n = int(input())
a = [int(x) for x in input().split()]
f = [0 for _ in range(101)]
for i in range(n):
	f[a[i]] += 1
print(max(f))


n = int(input())
ans = 0
ls = [int(x) for x in input().split()]
for i in range(n):
	ans = max(ls.count(ls[i]), ans)
print(ans)


n = int(input())
a = list(map(int, input().split()))
cnt = 1
for i in a:
	cnt = max(cnt, a.count(i))
print(cnt)


n = int(input())
a = [int(x) for x in input().split()]
b = 1
for i in a:
	b = max(b, a.count(i))
print(b)


input()
numbers = list(map(int, input().split()))
num = {}
for item in numbers:
	if item in num:
		num[item] += 1
	else:
		num[item] = 1
print(max(num.values()))


def mi():
	return map(int, input().split())
from collections import Counter
n = list(mi())[0]
a = Counter(list(mi()))
ma = -1
for i in a:
	if a[i] > ma:
		ma = a[i]
print(ma)


import os
import sys
import math
import heapq
from decimal import *
from io import BytesIO, IOBase
from collections import defaultdict, deque

def r():
	return int(input())

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

def rl():
	return list(map(int, input().split()))
n = r()
a = rl()
have = defaultdict(int)
for i in a:
	have[i] += 1
print(max(have.values()))


n = int(input())
a = list(map(int, input().split(' ')))
m = {}
for i in a:
	if i in m:
		m[i] += 1
	else:
		m[i] = 1
ans = 0
for (i, j) in m.items():
	ans = max(ans, j)
print(ans)


n = int(input())
a = list(map(int, input().split()))
max_n = 0
for i in a:
	if a.count(i) > max_n:
		max_n = a.count(i)
print(max_n)


n = int(input())
l = [int(x) for x in input().split()]
x = max(set(l), key=l.count)
c = 0
for i in range(n):
	if l[i] == x:
		c += 1
print(c)


from collections import Counter
n = int(input())
a = list(map(int, input().split()))
cnt = Counter(a)
ans = 0
for i in cnt.keys():
	ans = max(ans, cnt[i])
print(ans)


x = int(input())
lis = list(map(int, input().split()))
flag = 0
ct = 0
for i in range(x):
	for j in range(x):
		if lis[j] == lis[i]:
			flag += 1
	if flag > ct:
		ct = flag
	flag = 0
print(ct)


n = int(input())
max = []
for i in range(0, 101):
	max.append(0)
num = list(map(int, input().split()))
for i in range(0, n):
	number = num[i]
	max[number] = max[number] + 1
maximum = 0
for i in range(0, 101):
	if maximum < max[i]:
		maximum = max[i]
print(maximum)


from collections import Counter
n = int(input())
linp = map(int, input().split())
l = list(linp)
ctr = Counter(l)
res = 0
for i in set(l):
	res = max(res, ctr[i])
print(res)


import itertools
import math
import sys
import heapq
from collections import Counter
from collections import deque
from fractions import gcd
from functools import reduce
sys.setrecursionlimit(4100000)
INF = 1 << 60
MOD = 10 ** 9 + 7
n = int(input())
a = list(map(int, input().split()))
cnt = [0] * 100
for i in a:
	cnt[i - 1] += 1
print(max(cnt))


n = int(input())
L = list(map(int, input().split()))
x = max(set(L), key=L.count)
print(L.count(x))


from collections import Counter
numCoins = int(input())
coins = list(map(int, input().split()))
count = Counter(coins)
print(max(count.values()))


n = int(input())
a = list(map(int, input().split()))
l = []
for i in range(n):
	m = a.count(a[i])
	l.append(m)
print(max(l))


n = int(input())
a = list(map(int, input().split()))
cnt = [0] * (100 + 7)
for i in range(n):
	cnt[a[i]] += 1
print(max(cnt))


n = int(input())
a = input().split()
count = 100 * [0]
for i in range(len(a)):
	a[i] = int(a[i])
for i in range(len(a)):
	count[a[i] - 1] += 1
max = 0
for i in range(len(count)):
	if count[i] > max:
		max = count[i]
print(max)


(n, s, m) = (int(input()), input().split(), 0)
for i in range(len(s)):
	if s.count(s[i]) > m:
		m = s.count(s[i])
print(m)


while True:
	try:
		t = int(input())
	except:
		break
	dic = [0 for i in range(101)]
	max = 0
	coin = list(map(int, input().split()))
	for i in coin:
		dic[i] += 1
	for j in dic:
		if j >= max:
			max = j
	print(max)


from collections import Counter
n = int(input())
a = input().split()
for i in range(n):
	a[i] = int(a[i])
counte = Counter(a)
print(max(counte.values()))


a = []
n = int(input())
b = list(map(int, input().split()))
for i in b:
	c = True
	for j in a:
		if i not in j:
			j.append(i)
			c = False
			break
	if c:
		a.append([i])
print(len(a))


n = int(input())
L = input().split(' ')
for i in range(len(L)):
	L[i] = int(L[i])
d = {}
for i in L:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
l = d.values()
k = max(l)
print(k)


n = int(input())
s = input()
lst = s.split()
max = 0
for i in lst:
	nd = 0
	for j in lst:
		if j == i:
			nd += 1
	if nd > max:
		max = nd
print(max)


n = int(input())
a = list(map(int, input().split()))
a_used = [0] * n
ans = 0
while 0 in a_used:
	ans += 1
	tmp = []
	for i in range(n):
		if a[i] not in tmp and a_used[i] == 0:
			tmp.append(a[i])
			a_used[i] = 1
print(ans)


from math import ceil
t = 1
for test in range(t):
	n = int(input())
	a = list(map(int, input().split()))
	tmp = [0 for i in range(101)]
	for i in a:
		tmp[i] += 1
	print(max(tmp))


def karmany(lst):
	new = list()
	for elem in lst:
		new.append(lst.count(elem))
	return max(new)
n = int(input())
a = [int(i) for i in input().split()]
print(karmany(a))


n = int(input())
a = [int(x) for x in input().split()]
a = sorted(a)
a.append('x')
k = 0
c = 0
if n != 1:
	for i in range(1, n + 1):
		if a[i] != a[i - 1]:
			c = max(i - k, c)
			k = i
	print(c)
else:
	print(1)


input()
k = 0
p = list(map(int, input().split()))
for i in range(len(p)):
	k = p.count(p[i]) if p.count(p[i]) > k else k
print(k)


freq = {}
n = int(input())
x = []
x = [int(x) for x in input().split()]
for item in x:
	if item in freq:
		freq[item] += 1
	else:
		freq[item] = 1
max = 0
for item in freq:
	if freq[item] > max:
		max = freq[item]
print(max)


n = int(input())
ar = [int(x) for x in input().split()]
from collections import Counter
x = Counter(ar)
print(max(x.values()))


n = int(input())
arr = list(map(int, input().split()))
new_arr = sorted(arr)
j = 0
check = []
for i in range(n):
	if new_arr[j] < new_arr[i] and i not in check:
		check.append(i)
		j += 1
print(n - j)


from collections import Counter
input()
s = input().strip().split()
c = Counter(s)
print(max(c.values()))


n = int(input())
coins = map(int, input().split())
h = {}
for c in coins:
	h[c] = h.get(c, 0)
	h[c] += 1
print(max(h.values()))


n = int(input())
a = list(map(int, input().split()))
d = dict()
for ai in a:
	if ai in d:
		d[ai] += 1
	else:
		d[ai] = 1
print(max(d.values()))


n = int(input())
a = map(int, input().split())
d = [[] for x in range(100)]
for i in a:
	for j in range(100):
		if not i in d[j]:
			d[j].append(i)
			break
n = 0
for i in d:
	if i != []:
		n += 1
print(n)


n = int(input())
l = list(map(int, input().split()))
from collections import Counter
d = dict(Counter(l))
m = max(d.values())
print(m)


a = int(input())
b = input().split()
c = [0] * a
for i in range(a):
	c[i] = [0]
for i in range(a):
	for j in range(i + 2):
		if b[i] not in c[j]:
			c[j].append(b[i])
			break
for i in range(a):
	if [0] in c and c[i] == [0]:
		print(i)
		break
	elif [0] not in c:
		print(a)
		break


numofcoins = int(input())
coins = list(map(int, input().split()))
cont = [0] * 101
for i in coins:
	cont[i] += 1
maximum = 0
for i in cont:
	if i > maximum:
		maximum = i
print(maximum)


n = int(input())
nums = [int(x) for x in input().split()]
print(max([nums.count(x) for x in nums]))


n = int(input())
a = list(map(int, input().split()))
d = {}
res = 0
for i in a:
	if i not in d:
		d[i] = 1
	else:
		d[i] += 1
	if d[i] > res:
		res = d[i]
print(res)


a = int(input(''))
b = list(map(int, input().split()))
p = 0
t = []
l = 0
x = []
s = 0
z = 0
for i in range(len(b)):
	t.append(b[p])
	p = p + 1
while True:
	l = 0
	z = 0
	for kll in range(len(t)):
		if not t[l] in x:
			x.append(t[l])
		l = l + 1
	for kl in range(len(x)):
		t.remove(x[z])
		z = z + 1
	if len(t) == 0:
		break
	s = s + 1
	x = []
print(s + 1)


n = int(input())
arr = [int(i) for i in input().split()]
maxx = 0
arr_x = [0 for i in range(101)]
for i in arr:
	arr_x[i] += 1
	if arr_x[i] > maxx:
		maxx = arr_x[i]
print(maxx)


n = int(input())
arr = [int(i) for i in input().split()]
mp = dict()
for i in range(0, n):
	if mp.get(arr[i], 0) == 0:
		mp[arr[i]] = 1
	else:
		mp[arr[i]] += 1
b = list(mp.values())
li = int(len(b))
maxx = 0
for i in range(0, li):
	maxx = max(maxx, b[i])
print(maxx)


b = int(input())
s = list(map(int, input().split()))
max = 0
for e in s:
	current_value = s.count(e)
	if current_value > max:
		max = current_value
print(max)


n = int(input())
l = list(map(int, input().split()))
coins = []
for i in range(101):
	coins.append(0)
for i in l:
	coins[i] += 1
print(max(coins))


n = int(input())
a = [int(x) for x in input().split()]
c = max([a.count(x) for x in a])
print(c)


n = int(input())
maxx = -1
dict = [0] * 105
list = input().split()
for i in list:
	temp = int(i)
	dict[temp] += 1
	maxx = max(dict[temp], maxx)
print(maxx)


n = int(input())
arr = list(map(int, input().split()))
d = {}
for i in arr:
	if i in d.keys():
		d[i] += 1
	else:
		d[i] = 1
maxx = 0
for i in d.keys():
	maxx = max(maxx, d[i])
print(maxx)


n = input()
arr = [int(x) for x in input().split()]
d = {}
ans = 0
for x in arr:
	if x not in d:
		d[x] = 1
	else:
		d[x] += 1
for (key, val) in d.items():
	ans = max(ans, val)
print(ans)


n = int(input())
mas = list(map(int, input().split()))
k = 0
for i in range(n):
	if mas.count(mas[i]) > k:
		k = mas.count(mas[i])
print(k)


totalNumber = int(input())
numbers = list(map(int, input().split(' ')))
numberCount = {}
for i in numbers:
	if i in numberCount:
		numberCount[i] += 1
	else:
		numberCount[i] = 1
maxValue = 1
for i in numberCount.keys():
	maxValue = max(maxValue, numberCount.get(i))
print(maxValue)


n = int(input())
a = [int(s) for s in input().split()]
s = 0
for i in range(1, 101):
	s = max(s, a.count(i))
print(s)


massive = []
massiv2 = []
n = int(input())
massive = list(map(int, input().split()))
for i in range(1, 101):
	massiv2.append(massive.count(i))
otvet = max(massiv2)
print(otvet)


a = input()
b = list(map(int, input().split()))
c = 0
for i in b:
	if b.count(i) > c:
		c = b.count(i)
print(c)


n = int(input())
A = [int(x) for x in input().split()]
d = {}

def inDict(i):
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
for i in A:
	inDict(i)
B = [d[x] for x in d]
print(max(B))


n = int(input())
lst = list(map(int, input().split()))
ele = max(lst, key=lst.count)
print(lst.count(ele))


n = int(input())
l = list(map(int, input().split()))
d = {}
for i in l:
	d[i] = d.get(i, 0) + 1
mi = -1000
for i in d:
	if d[i] > mi:
		mi = d[i]
print(mi)


n = int(input())
a = list(map(int, input().split()))
cnt = [0] * 101
for x in a:
	cnt[x] += 1
res = 0
for x in cnt:
	res = max(res, x)
print(res)


class Main:

	def __init__(self):
		self.n = int(input())
		self.a = [int(x) for x in input().split()]

	def main(self):
		print(max((self.a.count(x) for x in set(self.a))))
Main().main()


n = int(input())
a = list(map(int, input().split()))
ma = 0
for i in set(a):
	if ma < a.count(i):
		ma = a.count(i)
print(ma)


n = int(input())
ar = list(map(int, input().split()))
ma = 0
for i in ar:
	if ar.count(i) > ma:
		ma = ar.count(i)
print(ma)


n = int(input())
arr = list(map(int, input().split()))
count = []
for i in arr:
	if arr.count(i) not in count:
		count.append(arr.count(i))
print(max(count))


n = int(input())
c = list(map(int, input().split()))
if len(set(c)) == len(c):
	print(1)
else:
	a = []
	for i in set(c):
		a.append(c.count(i))
	m = max(a)
	print(m)


n = int(input())
lis = input().split(' ')
count = []
Max = 0

def func(data=[]):
	data.append(0)
for i in range(0, len(lis)):
	func(count)
	for k in range(i + 1, len(lis)):
		if lis[i] == lis[k]:
			count[i] += 1
			if count[i] > Max:
				Max = count[i]
Max += 1
print(int(Max))


tmp = {}
i = input
n = int(i())
l = [*map(int, i().split())]
for j in l:
	if tmp.get(j, -1) == -1:
		tmp[j] = 1
	else:
		tmp[j] += 1
MAX = 0
for j in tmp.keys():
	if tmp[j] > MAX:
		MAX = tmp[j]
print(MAX)


n = int(input())
list1 = input().split()
count = 0
list0 = []
for i in list1:
	if i not in list0:
		leng = list1.count(i)
		list0.append(i)
		if count < leng:
			count = leng + 0
print(count)


n = int(input())
arr = list(map(int, input().split()))
max_ = max(arr, key=arr.count)
print(arr.count(max_))


n = int(input())
a = list(map(int, input().split()))
(d, mx) = ({}, -1e+64)
for v in a:
	if v in d:
		d[v] += 1
	else:
		d[v] = 1
for k in d:
	mx = max(mx, d[k])
print(mx)


def binNumber(n, size):
	return bin(n)[2:].zfill(size)

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
n = int(input())
a = list(map(int, input().split()))
a.sort()
j = 1
s = 1
for i in range(1, len(a)):
	if a[i] == a[i - 1]:
		j += 1
	else:
		s = max(j, s)
		j = 1
s = max(s, j)
print(s)


n = int(input())

def main():
	arr = [int(pnum) for pnum in input().split()]
	emlist = []
	flag = 0
	for i in range(n - 1):
		count = 0
		for j in range(n):
			if arr[i] == arr[j]:
				count = count + 1
			continue
		emlist.append(count)
	if emlist == []:
		print('1')
	else:
		max = 0
		for i in emlist:
			if i > max:
				max = i
		print(max)
main()


n = int(input())
l = [int(x) for x in input().split()]
s = list(set(l))
max = 0
for i in range(len(s)):
	x = sum([s[i] == l[x] for x in range(len(l))] * 1)
	if x >= max:
		max = x
print(max)


n = int(input())
p = list(map(int, input().split()))
q = list(set(p))
max = 0
for i in q:
	r = p.count(i)
	if r > max:
		max = r
print(max)


n = int(input())
m = list(map(int, input().split()))
mx = -float('inf')
for i in m:
	mx = max(mx, m.count(i))
print(mx)


n = int(input())
a = [0 for i in range(101)]
g = list(map(int, input().split()))
for x in g:
	a[x] += 1
print(max(a))


p = int(input())
array = list(map(int, input().split()))
a = max(array, key=array.count)
b = array.count(a)
print(b)


g = input()
lst = []
a = input().split()
for i in a:
	lst.append(a.count(i))
print(max(lst))


n = int(input())
a = list(map(int, input().split()))
b = list(set(a))
t = 0
for i in b:
	if a.count(i) == t:
		pass
	elif a.count(i) != t and a.count(i) > t:
		t = a.count(i)
print(t)


import math
n = int(input())
s = input().split()
k = 1
maxk = 1
for i in range(len(s)):
	s[i] = int(s[i])
for i in range(len(s) - 1):
	mini = s[i]
	minipos = i
	for j in range(i, len(s)):
		if mini > s[j]:
			mini = s[j]
			minipos = j
	(s[i], s[minipos]) = (s[minipos], s[i])
for i in range(1, len(s)):
	if s[i] == s[i - 1]:
		k += 1
	else:
		maxk = max(maxk, k)
		k = 1
maxk = max(maxk, k)
print(maxk)


n = int(input())
a = list(map(int, input().split()))
count = 0
if len(set(a)) == len(a):
	print(1)
else:
	for i in a:
		if a.count(i) > count:
			count = a.count(i)
	print(count)


from collections import Counter
n = int(input())
C = list(map(int, input().split()))
D = dict(Counter(C))
A = list(D.values())
print(max(A))


n = int(input())
a = str(input())
arr = a.split(' ')
maxx = 0
i = 0
while i < len(arr):
	if maxx < int(arr.count(arr[i])):
		maxx = arr.count(arr[i])
	i += 1
print(maxx)


n = int(input())
l = list(map(int, input().split()))
l.sort()
s = set(l)
max = -1
for i in s:
	x = l.count(i)
	if x > max:
		max = x
print(max)


n = int(input())
a = [int(i) for i in input().split()]
max = -10 ** 9
for i in range(0, len(a)):
	e = a.count(a[i])
	if e > max:
		max = e
print(max)


N = int(input())
coins = [int(x) for x in input().split()]
counts = {}
for coin in coins:
	counts[coin] = counts.get(coin, 0) + 1
if len(counts) > 0:
	print(max(counts.values()))
else:
	print(0)


def most_frequent(list1):
	counter = 0
	num = list1[0]
	for i in list1:
		current_frequency = list1.count(i)
		if current_frequency > counter:
			counter = current_frequency
			num = i
	return counter
n = int(input())
list1 = list(map(int, input().split()))
print(most_frequent(list1))


n = int(input())
x = list(map(int, input().split()))
ans = []
for i in set(x):
	ans.append(x.count(i))
print(max(ans))


num = int(input())
l = list(map(int, input().split()))
l.sort()
count = 1
prev_count = 1
for i in range(num - 1):
	count = 1
	for j in range(i + 1, num):
		if l[i] == l[j]:
			count += 1
	if count > prev_count:
		prev_count = count
print(prev_count)


n = int(input())
x = input().split()
ls = []
for i in range(n):
	ls.append(x.count(x[i]))
print(max(ls))


n = int(input())
l = []
p = 0
l = str(input()).split(' ')
t = set(l)
d = {}
for el in t:
	p = l.count(el)
	d[el] = p
y = list(d.values())
o = max(y)
print(o)


n = int(input())
l = list(map(int, input().split()))
t = 0
c = 0
for i in range(0, n):
	for j in l:
		if l[i] == j:
			c = c + 1
	if c > t:
		t = c
	c = 0
print(t)


from collections import defaultdict
n = int(input())
a = [int(i) for i in input().split()]
a_dict = defaultdict(int)
ans = 1
for i in a:
	a_dict[i] += 1
for i in a_dict:
	ans = max(ans, a_dict[i])
print(ans)


n = int(input())
l = list(map(int, input().split()))
k = []
s = list(set(l))
for i in s:
	c = l.count(i)
	k.append(c)
print(max(k))


import math

def solve(test):
	ans = 0
	d = [0 for i in range(101)]
	n = int(input())
	a = list(map(int, input().split()))
	for x in a:
		d[x] += 1
		ans = max(ans, d[x])
	print(ans)
t = 1
for _ in range(t):
	solve(_ + 1)


x = int(input())
l = list(map(int, input().split()))
r = max(set(l), key=l.count)
print(l.count(r))


n = int(input())
a = sorted(list(map(int, input().split())))
b = []
count = 1
if n == 1:
	print('1')
else:
	for i in range(n - 1):
		if a[i] == a[i + 1]:
			count += 1
		else:
			b.append(count)
			count = 1
		if i == n - 2:
			b.append(count)
	print(max(b))


from collections import defaultdict
n = int(input())
d = defaultdict(int)
a = [int(x) for x in input().split()]
mx = -1
for i in a:
	d[i] += 1
	mx = max(mx, d[i])
print(mx)


n = int(input())
st = input().split(' ')
arr = [int(x) for x in st]
dic = {}
for i in arr:
	dic[i] = dic.get(i, 0) + 1
print(max(dic.values()))


n = input()
ara = list(map(int, input().split()))
ans = 0
for i in range(1, 101):
	ans = max(ans, ara.count(i))
print(ans)


n = int(input())
l = [int(i) for i in input().split()]
m = 1
for i in l:
	if l.count(i) > m:
		m = l.count(i)
print(m)


input()
ls = input().split()
print(max((ls.count(i) for i in ls)))


x = int(input())
numbers = list(map(int, input().split()))
counters = []
for i in numbers:
	counters.append(numbers.count(i))
print(max(counters))


input()
a = input().split()
ans = 0
for x in a:
	ans = max(ans, a.count(x))
print(ans)


n = int(input())
a = list(map(int, input().strip().split(' ')))
count = [0] * 101
for i in a:
	count[i] += 1
print(max(count))


n = int(input())
a = list(map(int, input().split()))
dct = {}
for i in range(n):
	if a[i] not in dct.keys():
		dct[a[i]] = 1
	else:
		dct[a[i]] += 1
print(max(dct.values()))


n = int(input())
l = list(map(int, input().split()))
l1 = []
for i in range(len(l)):
	z = l.count(l[i])
	l1.append(z)
print(max(l1))


d = {}
n = int(input())
for i in input().split():
	i = int(i)
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
print(max(d.values()))


n = int(input())
amount = list(map(int, input().split()))
counter = 1
spisok = []
for k in amount:
	spisok.append(amount.count(k))
print(max(spisok))


n = int(input())
count = 0
l = list(map(int, input().split()))
d = dict()
for i in range(n):
	d[l[i]] = d.get(l[i], 0) + 1
print(max(d.values()))


n = int(input())
arr = input().split(' ')
dic = {}
maxx = 0
for i in arr:
	dic[i] = dic.get(i, 0) + 1
for (i, j) in dic.items():
	if j > maxx:
		maxx = j
print(maxx)


n = int(input())
ai = list(map(int, input().split()))
maxi = 1
ai.sort()
num = 1
for i in range(1, n):
	if ai[i] == ai[i - 1]:
		num += 1
	else:
		maxi = max(maxi, num)
		num = 1
maxi = max(maxi, num)
print(maxi)


n = int(input())
n1 = list(map(int, input().split()))
maxi = 0
for i in range(n):
	max = n1.count(n1[i])
	if max > maxi:
		maxi = max
print(maxi)


n = int(input())
a = [int(i) for i in input().split()]
num = [0] * 101
for i in a:
	num[i] += 1
print(max(num))


n = int(input())
v = [int(x) for x in input().split()]
c = [v.count(i) for i in v]
print(max(c))


import collections
n = int(input())
a = list(map(int, input().split()))
C = collections.Counter(a).most_common()
print(C[0][1])


n = int(input())
l = list(map(int, input().split()))
from collections import defaultdict
hash = defaultdict(int)
ans = 0
for i in l:
	hash[i] += 1
	ans = max(ans, hash[i])
print(ans)


from collections import Counter
n = int(input())
d = list(Counter(input().split()).items())
print(max(d, key=lambda d: d[1])[1])


n = int(input())
m = 0
s = list(map(int, input().split()))
for i in s:
	m = max(m, s.count(i))
print(m)


b = 1
n = int(input())
a = [int(i) for i in input().split()]
for i in range(n):
	if a.count(a[i]) > b:
		b = a.count(a[i])
print(b)


from collections import Counter
n = int(input())
coins = [int(c) for c in input().split()]
cnt = Counter(coins)
print(max(list(cnt.values())))


n = eval(input())
a = input().split()
for i in range(n):
	a[i] = int(a[i])
ans = 0
for i in range(n):
	temp = 0
	for j in range(n):
		if a[i] == a[j]:
			temp += 1
	if temp > ans:
		ans = temp
print(ans)


input()
max = 1
n = list(input().split(' '))
for _ in range(len(n)):
	if max < n.count(n[_]):
		max = n.count(n[_])
print(max)


num_coins = int(input())
all_coins = input()
all_coins = all_coins.split()
uni_coins = list(set(all_coins))
unique_coins = {}
for current_coin in uni_coins:
	unique_coins.update({current_coin: 0})
for current_coin in all_coins:
	unique_coins[current_coin] += 1
print(max(unique_coins.values()))


input()
arr = list(map(int, input().split()))
print(max((arr.count(x) for x in set(arr))))


input()
a = {}
for x in map(int, input().split()):
	a[x] = a.get(x, 0) + 1
print(max(a.values()))


n = int(input())
a = list(map(int, input().split(' ')))
a = sorted(a)
c = 0
count = [0] * (a[n - 1] + 1)
for i in range(0, n):
	count[a[i]] += 1
print(max(count))


from collections import Counter
n = int(input())
arr = list(map(int, input().split()))
d = Counter(arr)
m = 0
for x in d:
	if d[x] > m:
		m = d[x]
print(m)


n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
cur_ans = 1
ans = 1
for i in range(1, n):
	if a[i] == a[i - 1]:
		cur_ans += 1
	else:
		ans = max(ans, cur_ans)
		cur_ans = 1
ans = max(ans, cur_ans)
print(ans)


import math
import bisect
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from collections import Counter
I = lambda : int(input())
tup = lambda : map(int, input().split())
lst = lambda : list(map(int, input().split()))
t = 1
while t:
	n = I()
	arr = lst()
	temp = Counter(arr)
	max = max(list(temp.values()))
	print(max)
	t -= 1


n = int(input())
l = list(map(int, input().split()))
q = set(l)
ma = 0
for i in q:
	if l.count(i) > ma:
		ma = l.count(i)
print(ma)


import collections
pockets = collections.defaultdict(int)
coins = int(input())
line = list(input().strip().split())
for x in line:
	pockets[x] += 1
max = 0
for (key, value) in pockets.items():
	if max < value:
		max = value
print(max)


n = int(input())
coins = list(map(int, input().split()))
pockets = []
for i in range(0, n):
	pockets.append(coins.count(coins[i]))
print(max(pockets))


n = int(input())
l = sorted(list(map(int, input().split())))
ma = 1
h = 1
for f in range(n - 1):
	if l[f] == l[f + 1]:
		h += 1
		if h > ma:
			ma = h
	else:
		h = 1
print(ma)


arr = [0] * 101
ans = 0
n = int(input())
rrr = [0] * 999
rrr = list(map(int, input().split()))
for i in range(0, n):
	arr[rrr[i]] += 1
	ans = max(ans, arr[rrr[i]])
print(ans)


n = int(input())
a = list(map(int, input().split()))
ret = dict()
for j in a:
	if j not in ret:
		ret[j] = 1
	elif j in ret:
		ret[j] += 1
else:
	print(max(ret.values()))


n = int(input())
T = input().split(' ')
T.sort()
k = 1
m = 1
for i in range(1, n):
	if T[i] == T[i - 1]:
		k += 1
		if k > m:
			m = k
	else:
		k = 1
print(m)


n = int(input())
a = [int(i) for i in input().split()]
b = list(set(a))
o = 1
for i in b:
	c = a.count(i)
	if c > o:
		o = c
print(o)


number = int(input())
first = list(map(int, input().split()))
Max = 0
for i in first:
	Max = max(Max, first.count(i))
print(Max)


a = int(input())
lst = sorted(list(map(int, input().split())))
c = 0
for i in lst:
	if lst.count(i) > c:
		c = lst.count(i)
print(c)


n = int(input())
arr = list(map(int, input().split()))
d = {}
ma = 1
for i in arr:
	if i in d:
		d[i] += 1
		ma = max(ma, d[i])
	else:
		d[i] = 1
print(ma)


n = int(input())
a = list(map(int, input().split()))
a.sort()
i = 0
mx = 0
while i < n:
	x = a.count(a[i])
	i += x
	if x > mx:
		mx = x
print(mx)


from collections import Counter

def mode(L):
	counter = Counter(L)
	max_count = max(counter.values())
	return [item for (item, count) in counter.items() if count == max_count]
input()
li = [int(n) for n in input().split(' ')]
m = mode(li)[0]
n = 0
for i in li:
	if m == i:
		n += 1
print(n)


def count(my_list):
	freq = dict()
	for item in my_list:
		if item in freq:
			freq[item] += 1
		else:
			freq[item] = 1
	print(max(freq.values()))
n = int(input())
s = input()
temp = s.split()
count(temp)


def solon(arr):
	count = 1
	dicc = {}
	for i in arr:
		if i in dicc:
			dicc[i] += 1
			count = max(count, dicc[i])
		else:
			dicc[i] = 1
	print(count)
n = int(input())
arr = list(map(int, input().rstrip().split()))
solon(arr)


N = int(input())
L = list(map(int, input().split(' ')))
L1 = list(set(L))
S1 = []
for i in range(0, len(L1)):
	W = L.count(L1[i])
	if W not in S1:
		S1.append(W)
R = max(S1)
print(R)


n = int(input())
a = list(map(int, input().split()))
b = [0] * n
for i in range(n):
	b[i] = set()
c = 1
for elem in a:
	for i in range(c):
		if not elem in b[i]:
			b[i].add(elem)
			break
	else:
		b[c].add(elem)
		c += 1
print(c)


n = int(input())
ls = list(map(int, input().split()))
d = {}
ans = -1
for i in range(0, n):
	if ls[i] in d:
		d[ls[i]] += 1
	else:
		d[ls[i]] = 1
	ans = max(ans, d[ls[i]])
print(ans)


from collections import defaultdict
n = int(input())
l = list(map(int, input().split()))
d = defaultdict(int)
for i in l:
	d[i] += 1
print(max(d.values()))


x = int(input())
l = list(map(int, input().split()))
max = 0
for i in l:
	p = l.count(i)
	if p >= max:
		max = p
print(max)


from collections import Counter
n = int(input())
print(max([i[1] for i in Counter([int(i) for i in input().split()]).items()]))


n = int(input())
vals = map(int, input().split())
counts = [0] * 101
for v in vals:
	counts[v] += 1
print(max(counts))


n = int(input())
a = [int(m) for m in input().split()]
ans = 0
b = dict()
for i in a:
	b[i] = b.get(i, 0) + 1
for (i, j) in b.items():
	ans = max(ans, j)
print(ans)


from collections import Counter
n = input()
x = [int(x) for x in input().split()]
c = Counter(x)
if len(c) == len(x):
	print(1)
else:
	for i in c.most_common(1):
		print(i[1])


n = int(input())
l = list(map(int, input().split()))
dic = dict()
mini = 101
for e in l:
	if e in dic:
		dic[e] += 1
	else:
		dic[e] = 1
print(max(dic.values()))


n = int(input())
a = [int(i) for i in input().strip().split(' ')]
total = 0
for i in range(n):
	c = a.count(a[i])
	if c > total:
		total = c
print(total)


import collections
n = int(input())
a = list(map(int, input().split()))
d = collections.defaultdict(lambda : 0)
for i in a:
	d[i] += 1
ans = max(d.values())
print(ans)


import sys
input = sys.stdin.readlines()
coins = input[1].split(' ')
coins = list(map(int, coins))
pockets = 1
for coin in coins:
	coin_no = coins.count(coin)
	if coin_no > pockets:
		pockets = coin_no
print(pockets)


n = int(input())
a = list(map(int, input().split()))
x = a.count(a[0])
for i in range(1, n):
	if a.count(a[i]) > x:
		x = a.count(a[i])
print(x)


n = int(input())
a = [int(_) for _ in input().split()]
d = {}
s = set(a)
for el in s:
	d[el] = 0
for el in a:
	d[el] += 1
print(max(d.values()))


n = int(input().strip())
vals = list(map(int, input().strip().split()))
max_repeated = 1
for i in range(len(vals)):
	this_repeated = 1
	for j in range(i + 1, len(vals)):
		if vals[j] == vals[i]:
			this_repeated += 1
	if this_repeated > max_repeated:
		max_repeated = this_repeated
print(max_repeated)


n = int(input())
array = tuple(map(int, input().split()))
max = 0
for i in array:
	x = array.count(i)
	if max < x:
		max = x
print(max)


num = int(input())
coins = input().split()
coins = [int(x) for x in coins]
prev = 0
i = 0
ocur = {}
for coin in coins:
	try:
		ocur[coin] += 1
	except:
		ocur[coin] = 1
print(max(ocur.values()))


input()
n = list(map(int, input().split()))
max = 0
for i in range(len(n)):
	if n.count(n[i]) > max:
		max = n.count(n[i])
print(max)


n = int(input().strip())
a = [int(x) for x in input().strip().split(' ')]
v = [0] * 101
for i in range(n):
	v[a[i]] += 1
print(max(v))


col = int(input())
coins = input()
coins = coins.split()
My_list = list()
for a in range(col):
	coins[a] = int(coins[a])
	cnt_coins = coins.count(coins[a])
	My_list.append(cnt_coins)
print(max(My_list))


from sys import stdin

def solve(tc):
	n = int(stdin.readline().strip())
	li = list(map(int, stdin.readline().split()))
	dic = [0 for i in range(100)]
	for a in li:
		dic[a - 1] += 1
	maxi = 0
	for i in range(100):
		maxi = max(maxi, dic[i])
	print(maxi)
LOCAL_TEST = not __debug__
if LOCAL_TEST:
	infile = __file__.split('.')[0] + '-test.in'
	stdin = open(infile, 'r')
tcs = int(stdin.readline().strip()) if LOCAL_TEST else 1
tc = 1
while tc <= tcs:
	solve(tc)
	tc += 1


n = int(input())
v = [0] * 200
for i in map(int, input().split()):
	v[i] += 1
ans = 0
for i in v:
	ans = max(ans, i)
print(ans)


n = int(input())
a = [int(i) for i in input().split()]
a.sort()
l = 0
c = 0
ma = 0
for i in a:
	if i == l:
		c += 1
	else:
		ma = max(ma, c)
		c = 1
	l = i
ma = max(ma, c)
print(ma)


n = int(input())
pockets = dict()
a = [int(x) for x in input().split()]
for v in a:
	if v in pockets:
		pockets[v] += 1
	else:
		pockets[v] = 1
ans = 0
for v in pockets.values():
	ans = max(ans, v)
print(ans)


n = int(input())
a = list(map(int, input().split()))
m = max(set(a), key=a.count)
print(a.count(m))


n = int(input())
a = list(map(int, input().split()))
maxi = 0
for x in range(len(a)):
	c = 1
	for y in range(x + 1, len(a)):
		if a[x] == a[y]:
			c += 1
	maxi = max(maxi, c)
print(maxi)


input()
arr = str(input()).split(' ')
import collections
c = collections.Counter(arr)
print(c.most_common(1)[0][1])


n = int(input())
j = 0
l = list(map(int, input().split()))
for i in set(l):
	j = max(j, l.count(i))
print(j)


n = int(input())
a = [int(i) for i in input().split()]
a.sort()
(l, j, m) = (0, 0, 0)
for i in range(n):
	if a[i] == a[j]:
		l += 1
	else:
		j = i
		l = 1
	if l > m:
		m = l
print(m)


n = int(input())
num_arr = [0 for i in range(0, 101)]
a = [int(x) for x in input().split()]
ans = 0
for x in a:
	num_arr[x] += 1
for x in num_arr:
	ans = max(ans, x)
print(ans)


n = int(input())
a = list(map(int, input().split()))
a.sort()
b = []
k = 1
for i in range(n - 1):
	if a[i] == a[i + 1]:
		k += 1
	else:
		b.append(k)
		k = 1
b.append(k)
if b == []:
	print(1)
else:
	print(max(b))


input()
num = {}
maxn = 0
for i in list(map(int, input().split())):
	num[i] = num.get(i, 0) + 1
	maxn = max(maxn, num[i])
print(maxn)


def solve():
	n = int(input())
	m = [0] * 101
	mas = [int(s) for s in input().split()]
	ans = 0
	for x in mas:
		m[x] += 1
		ans = max(ans, m[x])
	print(ans)
solve()


n = int(input())
l = list(map(int, input().split()))
ans = 0
k = set(l)
for i in k:
	c = l.count(i)
	if c > ans:
		ans = c
	else:
		continue
print(ans)


n = int(input())
l = list(map(int, input().split(' ')))
l1 = []
max = 0
for i in l:
	if i not in l1:
		c = l.count(i)
		if c > max:
			max = c
print(max)


from collections import Counter
n = int(input())
k = [int(x) for x in input().split()]
c = Counter(k)
print(max(c.values()))


import sys
from collections import defaultdict as dd
from itertools import permutations as pp
from itertools import combinations as cc
from collections import Counter as ccd
from random import randint as rd
from bisect import bisect_left as bl
import heapq
mod = 10 ** 9 + 7

def ri(flag=0):
	if flag == 0:
		return [int(i) for i in input().split()]
	else:
		return int(input())
n = ri(1)
a = ri()
a = ccd(a)
ans = 0
for i in a:
	ans = max(ans, a[i])
print(ans)


n = int(input())
L = sorted([int(i) for i in input().split()])
cnt = 0
max_ = 1
L.append('0')
for i in range(len(L) - 1):
	if L[i] == L[i + 1]:
		cnt += 1
	else:
		if cnt + 1 > max_:
			max_ = cnt + 1
		cnt = 0
print(max_)


n = int(input())
a = list(map(int, input().split()))
ans = 1
for i in range(n):
	if a.count(a[i]) > 1 and a.count(a[i]) > ans:
		ans += a.count(a[i]) - ans
print(ans)


n = int(input())
a = []
x = [int(p) for p in input().split(' ')]
for i in range(n):
	if x[i] != 0:
		a.append(x.count(x[i]))
print(max(a))


n = int(input())
coins = [int(i) for i in input().split()]
coins.sort()
count = 1
new = 1
for i in range(n - 1):
	if coins[i + 1] == coins[i]:
		new += 1
		if new > count:
			count = new
	else:
		if new > count:
			count = new
		new = 1
print(count)


t = int(input())
s = input().split()
dic = {x: s.count(x) for x in s}
print(max(dic.values()))


n = int(input())
coins = list(map(int, input().split()))
(count, max_count) = (0, 0)
b = [0] * 101
for i in range(n):
	b[coins[i]] += 1
print(max(b))


n = int(input())
l = list(map(int, input().split()))
l.sort()
c = 1
m = 0
for i in range(n - 1):
	if l[i] == l[i + 1]:
		c -= -1
	else:
		m = max(m, c)
		c = 1
if c != 0:
	m = max(m, c)
print(m)


from __future__ import print_function
import sys
import math
import os.path
import random
from copy import deepcopy
from functools import reduce
from collections import Counter, ChainMap, defaultdict
from itertools import cycle, chain
from queue import Queue, PriorityQueue
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, nlargest, nsmallest
import bisect
from statistics import mean, mode, median, median_low, median_high
sys.setrecursionlimit(10 ** 9)

def log(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

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

def nio(offset):
	return map(lambda x: int(x) + offset, input().split())

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

def toString(aList, sep=' '):
	return sep.join((str(x) for x in aList))

def toMapInvertIndex(aList):
	return {k: v for (v, k) in enumerate(aList)}

def sortId(arr):
	return sorted(range(arr), key=lambda k: arr[k])
(n,) = ni()
a = nia()
c = Counter(a)
print(max(c.values()))


n = int(input())
a = list(map(int, input().split()))
c = n * [0]
for i in range(n):
	for u in range(n):
		if a[i] == a[u]:
			c[u] += 1
print(max(c))


n = int(input())
aw_dict = {}
for i in map(int, input().split()):
	aw_dict[i] = aw_dict.get(i, 0) + 1
print(max(aw_dict.values()))


n = int(input())
l = list(map(int, input().split()))
s = set(l)
x = [l.count(i) for i in s]
print(max(x))


n = int(input())
a = list(map(int, input().split()))
d = {}
for i in a:
	if i in d.keys():
		d[i] += 1
	else:
		d[i] = 1
v = [i for i in d.values()]
v.sort()
print(v[len(v) - 1])


from collections import Counter
T = int(input())
a = [int(n) for n in input().split()]
b = Counter(a)
c = b.values()
print(max(c))


n = int(input())
l = list(map(int, input().split()))
se = set(l)
max1 = 0
for i in se:
	if l.count(i) > max1:
		max1 = l.count(i)
print(max1)


n = int(input())
a = list(map(int, input().split()))
s = max(a, key=lambda x: a.count(x))
print(a.count(s))


n = int(input())
ls = [0 for i in range(101)]
a = input().split()
for i in range(n):
	ls[int(a[i])] += 1
print(max(ls))


class pockets:

	def __init__(self, m):
		self.m = []
		self.m.append(m)
c = int(input())
val = []
p = 1
val = list(map(int, input().strip().split(' ')))
l = []
for i in range(c):
	if len(l) < 1:
		l.append(pockets(val[i]))
	else:
		for j in range(len(l)):
			added = 0
			if val[i] not in l[j].m:
				l[j].m.append(val[i])
				added = 1
				break
			else:
				continue
		if added == 0:
			l.append(pockets(val[i]))
			p = p + 1
print(p)


from collections import Counter
n = int(input())
l = [int(x) for x in input().split()]
h = Counter(l)
f = h.most_common(1)
print(f[0][1])


n = int(input())
x = sorted(list(map(int, input().split())))
y = set(x)
print(max([x.count(i) for i in y]))


def calc(n, a):
	dic = {}
	m = 0
	for i in a:
		if i in dic:
			dic[i] += 1
		else:
			dic[i] = 1
		m = max(m, dic[i])
	print(m)
n = int(input())
a = list(map(int, input().split()))
calc(n, a)


n = int(input())
ar = list(map(int, input().split()))
cnt = [0 for i in range(101)]
for i in range(n):
	cnt[ar[i]] += 1
print(max(cnt))


n = int(input())
arr = list(map(int, input().split()))
ted = [0 for i in range(110)]
for x in arr:
	ted[x] += 1
print(max(ted))


n = int(input())
coins = [int(s) for s in input().split()]
C = {}
for elem in coins:
	if elem in C.keys():
		C[elem] += 1
	else:
		C[elem] = 1
MAX = 0
for elem in C.keys():
	if MAX < C[elem]:
		MAX = C[elem]
print(MAX)


n = int(input())
s = input().split()
sl = []
for i in range(n):
	sl.append(int(s[i]))
tsl = [0] * n
for i in range(n):
	for j in range(n):
		if sl[i] == sl[j]:
			tsl[i] += 1
mymax = 0
for i in range(n):
	if tsl[i] > mymax:
		mymax = tsl[i]
print(mymax)


input()
l = list(map(int, input().split()))
ans = {}
max = 1
for i in l:
	if i not in ans.keys():
		ans[i] = 1
	else:
		ans[i] += 1
		if ans[i] > max:
			max = ans[i]
print(max)


n = int(input())
ar = list(map(int, input().split()))
aw = [0] * 101
for i in ar:
	aw[i] += 1
q = max(aw)
print(q)


import queue
import sys
input = sys.stdin.readline

def main():
	N = int(input())
	a = list(map(int, input().split()))
	dic = {}
	for num in a:
		if num in dic:
			dic[num] += 1
		else:
			dic[num] = 1
	print(max(dic.values()))
	return
main()


n = int(input())
arr = [int(x) for x in input().split()]
arr.sort()
ans = 0
k = 0
temp = 0
for i in arr:
	if i != k:
		k = i
		ans = max(temp, ans)
		temp = 0
	temp += 1
ans = max(temp, ans)
print(ans)


n = input()
arr = list(map(int, input().split()))
new_arr = list(set(arr))
maxx = 0
for i in new_arr:
	ans = arr.count(i)
	if ans >= maxx:
		maxx = ans
print(maxx)


from collections import Counter as c
input()
print(max(c(input().split()).values()))


n = int(input())
arr = input().split()
for i in range(n):
	arr[i] = int(arr[i])
max = 0
for i in arr:
	j = arr.count(i)
	if max < j:
		max = j
print(max)


n = int(input())
a = [int(x) for x in input().split()]
d = {}
for i in a:
	if i not in d:
		d[i] = 1
	else:
		d[i] = d[i] + 1
ans = 0
for i in d:
	if d[i] > ans:
		ans = d[i]
print(ans)


n = int(input())
a = list(map(int, input().split()))
a.sort()
i = 0
count = 0
while i < n:
	num = a.count(a[i])
	i += num
	if num > count:
		count = num
print(count)


t = int(input())
a = [0] * 101
b = list(map(int, input().split()))
for i in b:
	a[i] = a[i] + 1
max = 0
for i in a:
	if max < i:
		max = i
print(max)


input()
count = dict()
for x in input().split():
	if count.get(x) == None:
		count[x] = 1
	else:
		count[x] = count[x] + 1
count = max(count.values())
print(count)


n = int(input())
a_i = [int(x) for x in input().split()]
a_j = set(a_i)
max = 0
for x in a_j:
	if max < a_i.count(x):
		max = a_i.count(x)
print(max)


n = int(input())
A = list(map(int, input().split()))
cnt = [0 for i in range(max(A) + 1)]
ans = 0
for i in A:
	cnt[i] += 1
	ans = max(cnt[i], ans)
print(ans)


a = int(input())
b = input().split()
print(max((b.count(i) for i in b)))


from collections import Counter
num_of_coins = int(input())
value_of_coins = list(map(int, input().split()))
coinsFrequency = Counter(value_of_coins)
maximum = max(coinsFrequency, key=coinsFrequency.get)
print(coinsFrequency[maximum])


n = int(input())
m = list(map(int, input().split()))
m.sort()
a = 0
b = 1
for i in range(n - 1):
	if m[i + 1] == m[i]:
		b += 1
	else:
		if a < b:
			a = b
		b = 1
if b > a:
	a = b
print(a)


n = int(input())
a = list(map(int, input().split()))
v = 101 * [0]
m = 1
for i in range(n):
	v[a[i]] += 1
	m = max(m, v[a[i]])
print(m)


a = input()
a = list(map(int, input().split()))
max = 0
for el in range(101):
	if a.count(el) > max:
		max = a.count(el)
print(max)


from collections import Counter
path = 'input1'

def solution(line):
	cnt = Counter()
	for word in line:
		cnt[word] += 1
	print(max(cnt.values()))

def file_to_list(path):
	with open(path, 'r') as input_file:
		return input_file.readlines()

def main():
	import sys
	inp = sys.stdin.read()
	inp = inp.split()
	solution(inp[1:])
main()


from collections import Counter
n = int(input())
h = 0
lis = list(map(int, input().rstrip().split()))
a = Counter(lis)
b = a.most_common(1)
print(b[0][1])


charNum = int(input())
numArray = input().split()
b = 0
for x in numArray:
	if numArray.count(x) > b:
		b = numArray.count(x)
print(b)


n = int(input())
array = list(map(int, input().split()))
array.sort()
counter = 0
max_counter = 0
temp = array[0]
for i in range(n):
	if array[i] == temp:
		counter += 1
	else:
		if counter > max_counter:
			max_counter = counter
		temp = array[i]
		counter = 1
if counter > max_counter:
	max_counter = counter
print(max_counter)


n = int(input())
a = list(map(int, input().split()))
b = set(a)
l = []
for i in b:
	t = a.count(i)
	l.append(t)
print(max(l))


input()
lst = []
ls = []
for i in map(int, input().split(' ')):
	lst.append(i)
	ls.append(lst.count(i))
print(max(ls))


from collections import Counter
n = int(input())
l = list(map(int, input().split()))
d = Counter(l)
val = []
for (k, v) in d.items():
	val.append(v)
print(max(val))


n = int(input().strip())
coins = input().strip().split()
print(max([coins.count(x) for x in set(coins)]))


n = int(input())
mn = list(map(int, input().split()))
k = 1
for i in range(1, 101):
	s = mn.count(i)
	if s > k:
		k = s
print(k)


import sys
n = int(sys.stdin.readline())
liste = list(map(int, sys.stdin.readline().split()))
seen = [0] * 200
maxi = 0
for loop in range(n):
	seen[liste[loop]] += 1
	maxi = max(maxi, seen[liste[loop]])
print(maxi)


n = int(input())
ls = list(map(int, input().split()))
kq = 0
for item in ls:
	kq = max(kq, ls.count(item))
print(kq)


import sys
input = sys.stdin.readline
print = sys.stdout.write
arr = [0] * 101
n = input().strip('\n')
a = list(map(int, input().strip('\n').split()))
for i in a:
	arr[i] += 1
print(str(max(arr)) + '\n')


n = int(input())
args = input().split(' ')
for i in range(0, len(args)):
	args[i] = int(args[i])
m = 0
for arg in args:
	if m < args.count(arg):
		m = args.count(arg)
print(m)


n = int(input())
lst = list(map(int, input().split()))
maxi = 1
for i in range(n):
	x = lst.count(lst[i])
	if x > maxi:
		maxi = x
print(maxi)


n = int(input())
li = []
li = list(map(int, input().split(' ')))
c = 0
for i in li:
	p = li.count(i)
	if p > c:
		c = p
print(c)


n = int(input())
a = list(map(int, input().split()))
s = {}
for i in a:
	if i in s:
		s[i] += 1
	else:
		s[i] = 1
ans = 1
for i in s:
	ans = max(ans, s[i])
print(ans)


a = int(input())
li = []
b = list(map(int, input().split()))
for x in range(a):
	li.append(b.count(b[x]))
print(max(li))


n = int(input())
A = [0 for _ in range(100)]
for i in input().split():
	A[int(i) - 1] += 1
print(max(A))


n = int(input())
L = list(map(int, input().split()))
max = 1
for i in L:
	nb = 0
	for j in L:
		if i == j:
			nb = nb + 1
	if max < nb:
		max = nb
print(max)


from collections import Counter
input()
ls = list(map(int, input().split()))
print(Counter(ls).most_common(1)[0][1])


input()
t = input().split()
print(max((t.count(x) for x in t)))


def main():
	n = int(input())
	x = list(map(int, input().split()))
	dict1 = {}
	for i in x:
		if i in dict1.keys():
			dict1[i] += 1
		else:
			dict1[i] = 1
	print(max(dict1.values()))
main()


n = int(input())
l = list(map(int, input().split()))
arr = []
for i in range(105):
	arr.append(0)
for k in range(n):
	inp = l[k]
	arr[inp] = arr[inp] + 1
print(max(arr))


n = input()
t = list(map(int, input().split()))
c = 0
for i in t:
	if t.count(i) > c:
		c = t.count(i)
print(c)


from collections import Counter
n = int(input())
arr = list(map(int, input().split()))
c = Counter(arr)
m = 1
for (key, value) in c.items():
	if value > m:
		m = value
print(m)


inp1 = int(input())
x = list(map(int, input().split()))
z = {}
for i in range(inp1):
	if x[i] in z:
		z[x[i]] += 1
	else:
		z[x[i]] = 1
print(max(z.values()))


n = int(input())
a = list(map(int, input().split()))
repeats = [0] * n
max_repeats = 0
for i in range(n):
	repeats[i] = a.count(a[i])
	if repeats[i] > max_repeats:
		max_repeats = repeats[i]
print(max_repeats)


(a, d) = (input(), input().split())
print(max((d.count(i) for i in set(d))))


n = int(input())
a = list(map(int, input().split()))
d = {}
for i in a:
	try:
		d[i] += 1
	except:
		d[i] = 1
m = -1
for i in d:
	m = max(m, d[i])
print(m)


n = int(input())
s = [int(i) for i in input().split()]
maxT = 0
for i in s:
	t = 0
	for j in s:
		if i == j:
			t += 1
	if t > maxT:
		maxT = t
print(maxT)


n = int(input())
a = []
for i in input().split():
	a.append(int(i))
maxcnt = 0
for i in range(n):
	d = a.count(a[i])
	if d > maxcnt:
		maxcnt = d
print(maxcnt)


n = int(input())
li = [int(x) for x in input().split()]
from collections import Counter
print(Counter(li).most_common(1)[0][1])


n = int(input())
list1 = list(map(int, input().split(' ')))
hashi = [0] * 101
for j in list1:
	hashi[j] += 1
hashi.sort()
print(hashi[-1])


a = int(input())
b = [int(i) for i in input().split()]
m = 0
for i in b:
	if b.count(i) > m:
		m = b.count(i)
print(m)


input()
a = list(map(int, input().split()))
s = [0] * 101
for i in a:
	s[i] += 1
print(max(s))


from collections import Counter
n = int(input())
a = list(map(int, input().split()))
k = Counter(a)
maxi = 0
for i in k:
	if maxi < k[i]:
		maxi = k[i]
print(maxi)


p = int(input())
a = 1
b = 0
y = input().split()
x = set(y)
x = len(x)
o = {i: 0 for i in set(y)}
for i in y:
	o[i] += 1
for i in o:
	if o[i] > b:
		b = o[i]
print(b)


n = int(input())
a = list(map(int, input().strip().split()))[:n]
flag = 1
b = []
for i in range(n):
	x = a[i + 1:n]
	y = x.count(a[i])
	b.append(y + 1)
print(max(b))


n = int(input())
coins = [int(x) for x in input().split()]
coins = sorted(coins)
count = 1
m_count = 1
for i in range(n - 1):
	if coins[i] == coins[i + 1]:
		count += 1
	else:
		count = 1
	if count > m_count:
		m_count = count
print(m_count)


from collections import Counter

def mc(lst):
	data = Counter(lst)
	return data.most_common(1)[0][1]
n = int(input())
a = [int(x) for x in input().split(' ')]
print(mc(a))


n = int(input())
a = list(map(int, input().split()))
f = [0] * 101
for i in a:
	f[i] += 1
print(max(f))


a = int(input())
li = list(map(int, input().split()))
l = []
for i in range(len(li)):
	l.append(li.count(li[i]))
print(max(l))


n = int(input())
lst = [int(x) for x in input().split()]
d = {}
for x in lst:
	if not x in d:
		d[x] = 0
	d[x] += 1
maxi = 0
for (x, y) in list(d.items()):
	maxi = max(maxi, y)
print(maxi)


n = int(input())
alist = list(map(int, input().split()))
alist = sorted(alist)
(k, p) = (1, 1)
for i in range(n - 1):
	if alist[i] != alist[i + 1]:
		k = 1
	else:
		k += 1
	if k > p:
		p = k
print(p)


n = int(input())
a = [int(x) for x in input().split()]
maxi = 0
for i in a:
	maxi = max(maxi, a.count(i))
print(maxi)


n = int(input())
a = list(map(int, input().split(' ')))
am = [0 for i in range(100)]
for i in a:
	am[i - 1] += 1
max = 0
for i in am:
	if i > max:
		max = i
print(max)


n = int(input())
a = list(map(int, input().strip().split(' ')))
mp = {}
for i in a:
	if i in mp:
		mp[i] += 1
	else:
		mp[i] = 1
ans = 0
for i in mp:
	if ans < mp[i]:
		ans = mp[i]
print(ans)


rep = {}
n = int(input())
given = list(map(int, input().split()))
for i in given:
	if i not in rep:
		rep[i] = 1
	else:
		rep[i] += 1
print(max(list(rep.values())))


n = int(input())
res = 0
l = [0] * 101
for i in [int(x) for x in input().split()]:
	l[i] += 1
print(max(l))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	a = collections.Counter(LI())
	return max(a.values())
print(main())


rs = 0
n = input()
coin = input().split()
for i in coin:
	if coin.count(i) > rs:
		rs = coin.count(i)
print(rs)


n = int(input())
l = list(map(int, input().split()))
D = {}
zz = 0
if n == 1:
	print(1)
elif n == 2:
	if l[0] == l[1]:
		print(2)
	else:
		print(1)
else:
	for i in range(len(l)):
		if l[i] in D:
			D[l[i]] += 1
		else:
			D[l[i]] = 1
	L = []
	for i in D:
		L.append(D[i])
	print(max(L))


n = int(input())
a = input().split()
o = 0
for x in set(a):
	o = max(o, a.count(x))
print(o)


n = int(input())
lst = list(map(int, input().strip().split()))
max_count = 0
for i in lst:
	count = lst.count(i)
	max_count = max(max_count, count)
print(max_count)


n = int(input())
k = input().split()
a = set(k)
m = 1
for i in a:
	if k.count(i) > m:
		m = k.count(i)
print(m)


import sys
n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().strip().split(' ')))
if n != len(a):
	print('!!!')
a.sort()
res = 0
i = 0
for j in range(n):
	if a[i] != a[j]:
		if j - i > res:
			res = j - i
		i = j
if n - i > res:
	res = n - i
print(res)


n = int(input())
c = list(map(int, input().strip().split(' ')))
v = {}
for x in range(0, len(c)):
	v[c[x]] = 0
for x in range(0, n):
	v[c[x]] += 1
max = -1
for k in v.keys():
	if v[k] > max:
		max = v[k]
print(max)


x = int(input())
L = list(map(int, input().split()))
D = {L[i]: L.count(L[i]) for i in range(len(L))}
X = max(list(D.values()))
print(X)


from collections import Counter
n = int(input())
A = [int(i) for i in input().split()]
d = Counter(A)
li = []
for keys in d:
	li.append(d[keys])
li.sort()
print(li[len(li) - 1])


n = input()
read = input()
read = read.split()
dict = {}
for i in range(int(n)):
	dict[read[i]] = 0
max = 0
for i in range(int(n)):
	dict[read[i]] += 1
	if max < dict[read[i]]:
		max = dict[read[i]]
print(max)


a = int(input())
l = list(map(int, input().split()))
ans = []
l1 = set(l)
l1 = list(l1)
for i in range(len(l1)):
	ans.append(l.count(l1[i]))
print(max(ans))


n = int(input())
s = input()
s = s.split(' ')
for i in range(len(s)):
	s[i] = int(s[i])
a = [0] * 100
for i in range(len(s)):
	a[s[i] - 1] = a[s[i] - 1] + 1
a.sort()
print(a[99])


n = int(input())
l = list(map(int, input().split()))
max = 0
for i in l:
	num = l.count(i)
	if num >= max:
		max = num
print(max)


n = [int(i) for i in input().split()]
list1 = [int(i) for i in input().split()]
list1.sort()
curr = 1
maxim = 0
num = -1
for i in range(len(list1)):
	if num != list1[i]:
		num = list1[i]
		maxim = max(curr, maxim)
		curr = 1
	else:
		curr += 1
		maxim = max(curr, maxim)
print(maxim)


n = int(input())
s = list(map(int, input().split()))
x = 0
for i in range(1, max(s) + 1):
	x = [x, s.count(i)][s.count(i) > x]
print(x)


from collections import Counter
n = int(input())
print(max(Counter(input().split()).values()))


n = int(input())
numbers = list(map(int, input().split(' ')))
ls = [[numbers[0]]]
for i in range(1, n):
	flag = 0
	for j in range(0, len(ls)):
		if numbers[i] not in ls[j]:
			ls[j].append(numbers[i])
			flag = 1
			break
	if flag == 0:
		ls.append([numbers[i]])
print(len(ls))


n = int(input())
d = {}
a = input().split()
for i in a:
	d[i] = 0
maxn = -1000000000.0
for i in a:
	d[i] += 1
	maxn = max(maxn, d[i])
print(maxn)


n = int(input())
coins = list(map(int, input().split()))
m = 0
c = 0
for i in coins:
	k = coins.count(i)
	if k > m:
		m = k
		c = i
print(m)


import collections
while True:
	try:
		n = int(input())
		a = input().split()
		d = collections.Counter(a)
		print(d[max(d, key=lambda x: d[x])])
	except:
		break


n = int(input())
arr = []
for i in range(101):
	arr.append(0)
s = list(map(int, input().split()))
for j in range(n):
	k = s[j]
	arr[k] += 1
print(max(arr))


n = int(input())
a = [int(i) for i in input().split()]
dic = {}
for i in range(n):
	if a[i] in dic.keys():
		dic[a[i]] += 1
	else:
		dic[a[i]] = 1
print(max(dic.values()))


import operator
n = int(input())
mas = list(map(int, input().split()))
d = {}
uniq = set(sorted(mas))
for i in uniq:
	d[i] = 0
for i in mas:
	d[i] += 1
print(max(d.values()))


import sys

class Pocket:

	def __init__(self):
		self.arr = {}

	def input(self, inputs):
		for x in inputs:
			if x in self.arr:
				self.arr[x] += 1
			else:
				self.arr[x] = 1

	def cal(self):
		np = 0
		for val in self.arr:
			np = max(np, self.arr[val])
		return np

def main():
	n = int(sys.stdin.readline())
	inputs = [int(x) for x in sys.stdin.readline().split()]
	t = Pocket()
	t.input(inputs)
	print(t.cal())
main()


n = int(input())
l = list(map(int, input().split()))
count = 0
n1 = []
for i in range(n):
	n1.append(l.count(l[i]))
print(max(n1))


n = int(input())
arr = [int(i) for i in input().split()]
cnt = [0] * 105
for i in arr:
	cnt[i] += 1
print(max(cnt))


import sys
data = sys.stdin.readlines()
lis = []
for line in data:
	lis.append(line)

def dadd(key, dic):
	if key in dic:
		dic[key] += 1
	else:
		dic[key] = 1
	return dic
n = int(lis[0])
seq = list(map(int, lis[1].split()))
dic = {}
for elm in seq:
	dic = dadd(elm, dic)
maximum = max(dic, key=lambda x: dic[x])
print(dic[maximum])


from collections import Counter
n = int(input())
a = list(map(int, input().split()))
b = Counter(a)
c = []
for (k, v) in b.items():
	c.append(v)
print(max(c))


import sys, math
input = sys.stdin.readline

def inp():
	n = int(input())
	return n

def inlt():
	a = list(map(int, input().split()))
	return a

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	(a, b) = map(int, input().split())
	return (a, b)
t = 1
for tt in range(t):
	n = inp()
	a = inlt()
	a.sort()
	c = 1
	a.append(-1)
	q = 1
	for i in range(len(a) - 1):
		if a[i] == a[i + 1]:
			c = c + 1
		else:
			if c > q:
				q = c
			c = 1
	print(q)


n = int(input())
s = input()
s = s.split()
l = []
y = 0
for i in range(len(s)):
	s[i] = int(s[i])
x = max(s, key=s.count)
for i in range(len(s)):
	if s[i] == x:
		y = y + 1
print(y)


n = int(input())
l = list(map(int, input().split()))
c = 0
maxi = 0
for i in list(set(l)):
	c = l.count(i)
	maxi = max(maxi, c)
print(maxi)


a = int(input())
L = [int(x) for x in input().split()]
N = []
maks = 0
for i in range(len(L)):
	if L[i] not in N:
		N += [L[i]]
for i in range(len(N)):
	ma = 0
	for a in range(len(L)):
		if L[a] == N[i]:
			ma += 1
			L[i] = [-1]
	if ma > maks:
		maks = ma
print(maks)


def polycarp():
	if len(arr) == len(set(arr)):
		return 1
	cou = 1
	for ele in set(arr):
		c = arr.count(ele)
		if c > cou:
			cou = c
	return cou
coins = int(input())
arr = list(map(int, input().split()))
print(polycarp())


n = eval(input())
cnt = []
for i in range(107):
	cnt.append(0)
a = input().split()
for i in range(n):
	cnt[int(a[i])] += 1
ans = 0
for i in range(107):
	if cnt[i] > ans:
		ans = cnt[i]
print(ans)


import re
import math
import decimal
import bisect

def read():
	return input().strip()

def iread():
	return int(input().strip())

def viread():
	return list(map(int, input().strip().split()))
pockets = 0
n = iread()
nums = viread()
freq = [0 for _ in range(100)]
for i in nums:
	freq[i - 1] += 1
print(max(freq))


m = [0] * 101
N = int(input().strip())
A = list(map(int, input().strip().split()))
for n in A:
	m[n] += 1
ans = -1
for n in m:
	ans = max(ans, n)
print(ans)


n = int(input())
list = list(map(int, input().split()))
listset = set(list)
max = 0
for el in listset:
	if list.count(el) > max:
		max = list.count(el)
	else:
		pass
print(max)


n = int(input())
l1 = [int(i) for i in input().split(' ')]
s1 = set(l1)
max = 0
for i in s1:
	if l1.count(i) > max:
		max = l1.count(i)
print(max)


import sys

def pockets(n, a):
	res = 0
	for i in range(n):
		if a[i] > 0:
			c = 1
			for j in range(i + 1, n):
				if a[j] == a[i]:
					a[j] = 0
					c += 1
			if c > res:
				res = c
	return res
n = int(sys.stdin.readline())
a = list(map(int, sys.stdin.readline().strip().split(' ')))
if n != len(a):
	print('!!!')
print(pockets(n, a))


n = int(input())
a = list(map(int, input().split()))
b = {}
for ai in a:
	b[ai] = b.get(ai, 0) + 1
print(max(b.values()))


N = int(input())
lo = list(map(int, input().split()))
noi = []
for item in lo:
	mo = lo.count(item)
	noi.append(mo)
print(max(noi))


n = int(input())
a = list(map(int, input().split()))
d = [0 for i in range(105)]
for ai in a:
	d[ai] += 1
print(max(d))


n = int(input())
A = list(map(int, input().split()))
from collections import Counter
C = Counter(A)
ans = 1
for v in C.values():
	ans = max(ans, v)
print(ans)


m = 0
k = 0
import math
a = int(input())
b = list(map(int, input().split()))
b.sort()
i = b[a - 1]
b.append(0)
for i in range(a):
	if b[i] == b[i + 1]:
		m += 1
	else:
		if m > k:
			k = m
		m = 0
print(k + 1)


n = int(input())
l = [0] * 101
i = list(map(int, input().split()))
m = 0
for j in i:
	l[j] += 1
	if m < l[j]:
		m = l[j]
print(m)


n = int(input())
l = input().split()
l = [int(i) for i in l]
r = [0 for i in range(1, 101)]
for i in l:
	r[i - 1] += 1
print(max(r))


n = int(input())
v = [0] * 101
nums = map(int, input().split())
for num in nums:
	v[num] += 1
print(max(v))


x = int(input())
y = list(map(int, input().split(' ')))
y.sort()
a = [0]
b = 0
for i in range(len(y) - 1):
	if y[i] == y[i + 1]:
		b += 1
		a.append(b)
	else:
		b = 0
		pass
print(max(a) + 1)


def inline():
	return [int(e) for e in input().split()]

def outline(l):
	for e in l:
		print(e, end=' ')
	print()

def outlist(l):
	for e in l:
		print(e)

def empty(l):
	return len(l) == 0
n = int(input())
monedas = inline()
ans = list()
while not empty(monedas):
	ans.append(set())
	for m in monedas:
		if m not in ans[-1]:
			ans[-1].add(m)
	for added in ans[-1]:
		monedas.remove(added)
print(len(ans))


n = int(input())
l = list(map(int, input().split()))
ar = [0] * 101
for i in range(n):
	ar[l[i]] += 1
ar.sort()
print(ar[100])


import collections
from functools import cmp_to_key
import math
import sys

def getIntList():
	return list(map(int, input().split()))
import bisect
try:
	import numpy
	dprint = print
	dprint('debug mode')
except ModuleNotFoundError:

	def dprint(*args, **kwargs):
		pass

def makePair(z):
	return [(z[i], z[i + 1]) for i in range(0, len(z), 2)]

def memo(func):
	cache = {}

	def wrap(*args):
		if args not in cache:
			cache[args] = func(*args)
		return cache[args]
	return wrap

@memo
def comb(n, k):
	if k == 0:
		return 1
	if n == k:
		return 1
	return comb(n - 1, k - 1) + comb(n - 1, k)
(n,) = getIntList()
za = getIntList()
zz = collections.Counter(za)
zl = list(zz.values())
print(max(zl))


from collections import *
R = lambda : map(int, input().split())
n = int(input())
c = Counter(R())
print(c.most_common()[0][1])


import math
getInputList = lambda : list(input().split())
getInputIntList = lambda : list(map(int, input().split()))
n = int(input())
arr = getInputIntList()
c = []
for i in arr:
	c.append(arr.count(i))
print(max(c))


n = int(input())
a = [int(i) for i in input().split()]
p = set([])
for i in range(n):
	p.add(a.count(a[i]))
print(max(p))


n = int(input())
a = list(map(int, input().split()))
s = set(a)
c = []
for i in s:
	t = a.count(i)
	c.append(t)
s1 = set(c)
if len(c) > 1:
	if len(s1) == 1:
		print(c[0])
	else:
		m = max(c)
		t = c.count(m)
		if t == len(c):
			print(t)
		else:
			print(m)
else:
	print(n)


list1 = [0] * 100
coin = int(input())
str1 = [int(v) for v in input().split()]
for i in range(len(str1)):
	list1[str1[i] - 1] += 1
print(max(list1))


n = int(input())
b = list(map(int, input().split()))
t = []
for i in range(n):
	for j in range(1, 101):
		t.append(b.count(j))
print(max(t))


t = int(input())
L = [int(x) for x in input().split()]
F = []
for i in L:
	F.append(L.count(i))
print(max(F))


n = int(input())
arr = [int(i) for i in input().split()]
d = {}
for elem in arr:
	if elem in d:
		d[elem] += 1
	else:
		d[elem] = 1
print(max(list(d.items()), key=lambda x: x[1])[1])


n = int(input())
k = 0
kmax = 0
dif = []
a = [int(n) for n in input().split(' ')]
for i in range(len(a)):
	if dif.count(a[i]) == 0:
		dif.append(a[i])
for i in range(len(dif)):
	k = a.count(dif[i])
	if k > kmax:
		kmax = k
print(kmax)


from collections import Counter

def solution(arr, n):
	d = Counter(arr)
	best = 0
	for (key, val) in d.items():
		if val > best:
			best = val
	print(best)
n = [int(val) for val in input().split()]
arr = [int(val) for val in input().split()]
solution(arr, n)


n = int(input())
number = input()
numbersp = [int(x) for x in number.split()]
numbersp.sort()
counter = 1
maxs = 1
for i in range(1, n):
	if numbersp[i] == numbersp[i - 1]:
		counter += 1
	else:
		if counter > maxs:
			maxs = counter
		counter = 1
if counter > maxs:
	maxs = counter
print(maxs)


n = int(input())
l = list(map(int, input().strip().split()))
l1 = [0 for i in range(101)]
for i in l:
	l1[i] = l1[i] + 1
print(max(l1))


n = int(input(''))
hug = [int(x) for x in input().split()]
hug.sort()
max = 1
kal = 1
for i in range(n - 1):
	if hug[i] == hug[i + 1]:
		kal = kal + 1
	else:
		if kal > max:
			max = kal
		kal = 1
if kal > max:
	max = kal
print(max)


from itertools import groupby
n = int(input())
a = [int(i) for i in input().split()]
s = sorted(a)
keys = []
groups = []
length = []
for (k, g) in groupby(s):
	keys.append(k)
	groups.append(list(g))
for i in groups:
	length.append(len(i))
print(max(length))


n = input().strip()
lis = list(map(int, input().strip('').split(' ')))
maxi = 1
for x in lis:
	if maxi < lis.count(x):
		maxi = lis.count(x)
print(maxi)


from collections import Counter
n = int(input())
arr = list(map(int, input().split()))
freq = Counter(arr)
print(max(freq.values()))


f = lambda : map(int, input().split())
input()
cns = list(f())
cc = [cns.count(i) for i in set(cns)]
print(max(cc))


n = int(input())
l = list(map(int, input().split()))
m = [0 for j in range(100)]
for j in range(n):
	m[l[j] - 1] += 1
print(max(m))


n = input()
data = list(map(int, input().split()))
ans = max([data.count(i) for i in data])
print(ans)


import sys
from collections import Counter

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
A = LIST()
C = Counter(A)
ans = max(C.values())
print(ans)


n = int(input())
a = [int(x) for x in input().split()]
s = []
for i in range(max(a)):
	s.append(0)
for i in range(n):
	s[a[i] - 1] += 1
print(max(s))


n = int(input())
s = [int(i) for i in input().split()]
res = {}
for a in s:
	if a in res.keys():
		res[a] += 1
	else:
		res[a] = 1
m = 0
for i in res.keys():
	if res[i] > m:
		m = res[i]
print(m)


n = int(input())
arr = [int(x) for x in input().split()]
arr.sort()
pred = arr[0]
counter = 0
m = 0
for i in range(1, n):
	if pred == arr[i]:
		counter += 1
	else:
		if counter > m:
			m = counter
		counter = 0
	pred = arr[i]
if counter > m:
	m = counter
counter = 0
print(m + 1)


n = int(input())
s = input().split()
d = dict()
for i in range(n):
	if s[i] in d:
		d[s[i]] += 1
	else:
		d[s[i]] = 1
Max = 0
for i in range(n):
	if d[s[i]] > Max:
		Max = d[s[i]]
print(Max)


a = int(input())
n = list(map(int, input().split()))
n.sort()
i = 0
m = 1
k = 1
while i < len(n) - 1:
	if n[i] == n[i + 1]:
		k = k + 1
	else:
		k = 1
	if k > m:
		m = k
	i = i + 1
print(m)


n = int(input())
a = list(map(int, input().split()))
ans = 1
for num in a:
	ans = max(ans, a.count(num))
print(ans)


N = int(input())
val = [0] * 101
arr = input().split()
for n in range(0, N):
	h = int(arr[n])
	val[h] += 1
max = 0
for i in range(0, 101):
	if max < val[i]:
		max = val[i]
print(max)


import collections
n = int(input())
numbers = list(map(int, input().split()))
result = collections.Counter(numbers).most_common()[0][1]
print(result)


x = int(input())
z = []
s = [int(n) for n in input().split()]
for n in s:
	z.append(s.count(n))
print(max(z))


while True:
	try:
		s = input()
		l = list(map(int, input().split(' ')))
		if len(l) == len(set(l)):
			print(1)
			continue
		m = 0
		for i in l:
			m = max(m, l.count(i))
		if m == 1:
			print(1)
		else:
			print(m)
	except:
		break


from collections import Counter as c
n = int(input())
a = list(map(int, input().split()))
cnt = c(a)
cnt = sorted(cnt.items(), key=lambda x: x[1], reverse=True)
print(cnt[0][1])


k = eval(input())
l = list(map(eval, input().split(' ')))
s = set(l)
ans = 1
for i in s:
	p = l.count(i)
	if p > ans:
		ans = p
print(ans)


n = int(input())
arr = input().split()
arr = [int(i) for i in arr]
hash = []
for i in range(1, 102):
	hash.append(0)
maxi = 0
for i in arr:
	hash[i] += 1
	maxi = max(maxi, hash[i])
print(maxi)


n = int(input())
a = []
arr = input()
a = arr.split(' ')
for i in a:
	i = int(i)
m = 1
mi = 1
a.sort()
for i in range(1, n):
	if a[i] == a[i - 1]:
		m = m + 1
	else:
		if mi < m:
			mi = m
		m = 1
if mi < m:
	mi = m
print(mi)


input()
inp = [int(p) for p in input().split()]
dp = []
for i in inp:
	a = inp.count(i)
	dp.append(a)
print(max(dp))


input()
lst = list(map(int, input().split()))
print(max((lst.count(i) for i in set(lst))))


n = int(input())
x = [int(x) for x in input().split()]
list2 = []
for j in range(0, n):
	list2.append(x.count(x[j]))
list2.sort()
print(list2[n - 1])


m = int(input())
s = [int(x) for x in input().split()]
pockets = 1
if len(s) == 1:
	pockets = 1
else:
	counts = []
	n = [i for i in s if s.count(i) > 1]
	for k in n:
		counts.append(n.count(k))
		pockets = max(counts)
print(pockets)


num = int(input())
list1 = list(map(int, input().split()))
max = 0
for i in range(len(list1)):
	if max < list1.count(list1[i]):
		max = list1.count(list1[i])
print(max)


b = int(input())
a = list(map(int, input().split()))
c = a
c = list(set(c))
d = []
for i in range(len(c)):
	d.append(int(a.count(c[i])))
print(int(max(d)))


import sys
import math
import bisect

def main():
	n = int(input())
	A = list(map(int, input().split()))
	d = dict()
	for a in A:
		if a not in d:
			d[a] = 0
		d[a] += 1
	max_val = max(list(d.values()))
	print(max_val)
main()


n = int(input())
l = list(map(int, input().split()))
cou = 0
while n != 0:
	k = set(l)
	cou += 1
	for t in k:
		l.remove(t)
	n = len(l)
print(cou)


import math
import collections
N = int(input())
A = list(map(int, input().split()))
print(max(collections.Counter(A).values()))


n = int(input())
array = map(int, input().split())
counts = {}
maximum = 0
for v in array:
	counts[v] = counts.get(v, 0) + 1
	maximum = max(maximum, counts[v])
print(maximum)


n = int(input())
mylist = [int(x) for x in input().split()]
occ = []
for j in range(0, len(mylist)):
	occ.append(mylist.count(mylist[j]))
num = occ[0]
for k in range(0, len(mylist)):
	num = max(num, occ[k])
print(num)


def main():
	n = int(input())
	s = list(map(int, input().split()))
	ss = set(s)
	d = dict()
	(m, n) = (0, 0)
	for i in ss:
		d[i] = 0
	for i in s:
		d[i] += 1
	for (i, j) in d.items():
		if m < j:
			m = j
			n = i
	print(m)
main()


n = int(input())
xs = list(map(int, input().split(' ')))
freq = dict(zip(xs, [0 for i in range(len(xs))]))
for x in xs:
	freq[x] += 1
print(max(freq.values()))


num = int(input())
arr = list(map(int, input().split()))
maxPockets = 1
for i in range(num):
	count = 0
	for j in range(i, num):
		if arr[i] == arr[j]:
			count += 1
	if count >= maxPockets:
		maxPockets = count
print(maxPockets)


n = int(input())
l = list(map(int, input().split()))
l2 = []
for i in l:
	l2.append(l.count(i))
if len(set(l)) == 1:
	print(n)
elif len(set(l)) == n:
	print('1')
else:
	print(max(l2))


class CodeforcesTask1003ASolution:

	def __init__(self):
		self.result = ''
		self.n = 0
		self.coins = []

	def read_input(self):
		self.n = int(input())
		self.coins = [int(x) for x in input().split(' ')]

	def process_task(self):
		self.result = str(max([self.coins.count(x) for x in range(1, max(self.coins) + 1)]))

	def get_result(self):
		return self.result
Solution = CodeforcesTask1003ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


a = int(input())
b = [int(b) for b in input().split()]
sum = 1
d = 1
for i in range(a - 1):
	for j in range(i + 1, a):
		if b[i] == b[j]:
			d += 1
	if d > sum:
		sum = d
	d = 1
print(sum)


n = int(input())
arr = list(map(int, input().split()))
holder = []
holder.append([])
for i in range(len(arr)):
	flag = 0
	for j in range(len(holder)):
		if arr[i] in holder[j]:
			pass
		else:
			holder[j].append(arr[i])
			flag = 1
			break
	if flag == 0:
		holder.append([])
		holder[j + 1].append(arr[i])
print(len(holder))


n = int(input())
l = list(map(int, input().split()))
c1 = 1
for i in range(n):
	c = 1
	for j in range(i + 1, n):
		if l[i] == l[j]:
			c = c + 1
	if c > c1:
		c1 = c
print(c1)


n = int(input())
coins = list(map(int, input().split()))
count = {}
for i in coins:
	if i not in count:
		count[i] = 0
	count[i] += 1
print(max(count.values()))


n = int(input())
a = list(map(int, input().split()))
a.sort()
k = 0
x = 0
for i in range(1, n):
	if a[i] == a[i - 1]:
		k += 1
	else:
		if k > x:
			x = k
		k = 0
if x <= k:
	x = k
print(x + 1)


n = int(input())
l = list(map(int, input().split()))
y = list(set(l))
x = []
for i in range(len(y)):
	x.append(l.count(y[i]))
print(max(x))


n = int(input())
ls = input().split()
ls1 = list()
for i in range(n):
	ls1.append(ls.count(ls[i]))
print(max(ls1))


n = int(input())
a = [int(t) for t in input().split()]
c = [0] * 105
ans = 1
for i in a:
	c[i] += 1
	ans = c[i] if c[i] > ans else ans
print(ans)


input()
x = list(map(int, input().split()))
a = max(set(x), key=x.count)
print(x.count(a))


input()
a = input().split()
print(max((a.count(x) for x in a)))


import sys
import collections
import heapq
import math
import bisect
import itertools
input = sys.stdin.readline

def rints():
	return map(int, input().strip().split())

def rstr():
	return input().strip()

def rint():
	return int(input().strip())

def rintas():
	return [int(i) for i in input().strip().split()]

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
t = rint()
n = rintas()
counts = collections.Counter(n)
print(max(counts.values()))


x = input()
coins = [int(x) for x in input().split()]
pockets = 0
for i in range(max(coins) + 1):
	num = coins.count(i)
	if num > pockets:
		pockets = num
print(pockets)


T = int(input())
arr = list(map(int, input().split()))
arr.sort()
count = 1
temp = arr[0]
max = 1
for t in range(1, T):
	if arr[t] == temp:
		count += 1
	else:
		if count > max:
			max = count
		count = 1
		temp = arr[t]
	if t == T - 1:
		if count > max:
			max = count
print(max)


n = int(input())
arr = [int(x) for x in input().split()]
ptr = 0
for k in arr:
	if arr.count(k) > ptr:
		ptr = arr.count(k)
print(ptr)


a = int(input())
b = list()
c = list()
b = b + [int(b) for b in input().split()]
for i in b:
	c = c + [b.count(i)]
	a = max(c)
print(a)


a = int(input())
b = list(map(int, input().rstrip().split()))
c = [0] * 101
count = 0
for x in range(101):
	count = 0
	for y in range(a):
		if x == b[y]:
			count += 1
	c[x] = count
c.sort()
print(c[100])


n = int(input())
l = [int(i) for i in input().split()]
p = []
for i in l:
	if l.count(i) > 1:
		p.append(l.count(i))
if p == []:
	print(1)
else:
	print(max(p))


n = int(input())
li = list(map(int, input().split()))
li1 = [li.count(i) for i in set(li)]
print(max(li1))


input()
sp = [0] * 101
for el in list(map(int, input().split())):
	sp[el] += 1
print(max(sp))


a = int(input())
b = input().split()
b = list(map(int, b))
from collections import Counter
c = dict(Counter(b))
d = max(c.values())
print(d)


import collections
n = int(input())
A = list(map(int, input().split()))
C = collections.Counter(A)
ans = max(C.values())
print(ans)


n = input().strip()
coins = list(map(int, input().strip().split()))
pockets = []
for i in coins:
	pockets.append(coins.count(i))
print(max(pockets))


n = int(input())
c = list(map(int, input().split()))
p = set(c)
a = list(p)
m = 0
for i in a:
	m = max(m, c.count(i))
print(m)


n = int(input())
l = input().split()
l = list(map(int, l))
l = sorted(l)
ma = 1
count = 1
for i in range(1, n):
	if l[i] == l[i - 1]:
		count += 1
	else:
		if count > ma:
			ma = count
		count = 1
if count > ma:
	ma = count
print(ma)


n = int(input())
a = [int(x) for x in input().split()]
c = [0 for _ in range(0, 110)]
mx = 0
for x in a:
	c[x] += 1
	if c[x] > mx:
		mx = c[x]
print(mx)


from statistics import mode
n = int(input())
li = list(map(int, input().split()))
print(li.count(max(set(li), key=li.count)))


n = int(input())
arr = input().split()
l = [0 for i in range(101)]
for i in range(n):
	arr[i] = int(arr[i])
	l[arr[i]] = l[arr[i]] + 1
ans = max(l)
print(ans)


n = int(input())
b = [0] * 100
for x in input().split():
	b[int(x) - 1] += 1
print(max(b))


TN = 1

def solution():
	n = int(input())
	a = list(map(int, input().split()))
	l = list(set(a))
	d = {}
	k = []
	for i in range(len(l)):
		d[l[i]] = a.count(l[i])
		k.append(d[l[i]])
	print(max(k))
while TN != 0:
	solution()
	TN -= 1


from sys import stdin, stdout
from math import gcd, ceil, sqrt
from collections import Counter
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
n = ii1()
arr = iia()
pocket = [set()]
for i in arr:
	for j in pocket:
		if i not in j:
			j.add(i)
			break
	else:
		pocket.append(set([i]))
print(len(pocket))


n = int(input())
a = [int(x) for x in input().split()]
counts = [0 for _ in range(max(a) + 1)]
for coin in a:
	counts[coin] += 1
print(max(counts))


inp1 = int(input())
inp2 = input().split()
inp2 = list(map(int, inp2))
l = [0] * 100
k = 1
for i in range(inp1):
	l[inp2[i] - 1] = l[inp2[i] - 1] + 1
for i in range(100):
	if l[i] > 1 and k < l[i]:
		k = l[i]
print(k)


n = int(input())
a = list(map(int, input().split()))
(cnt, cnt1, ans) = (0, 0, 0)
for i in a:
	cnt1 = a.count(i)
	if cnt1 >= cnt:
		cnt = cnt1
		ans = cnt1
	else:
		ans = cnt
print(ans)


from collections import Counter

def A():
	N = int(input())
	c = Counter(input().split())
	print(c.most_common(1)[0][1])

def B():
	pass

def C():
	pass

def D():
	pass

def E():
	pass
A()


n = int(input())
arr = list(map(int, input().split()))
count = 1
m = 1
arr.sort()
for i in range(1, n):
	if arr[i] == arr[i - 1]:
		count += 1
	else:
		count = 1
	if m < count:
		m = count
print(m)


max = 0
n = input()
list = input().split()
for i in list:
	if list.count(i) > max:
		max = list.count(i)
print(max)


size = int(input())
arr = list(map(int, input().split(' ')))
print(max([arr.count(i) for i in set(arr)]))


import os
N = int(100.0 + 1)
fr = [0] * N
inp = os.read(0, int(100000.0)).split()
n = int(inp[0])
a = [None] * n
for i in range(n):
	a[i] = int(inp[i + 1])
for item in a:
	fr[item] += 1
os.write(1, str(sorted(fr)[-1]).encode())


from collections import Counter
input()
l = list(map(int, input().split()))
k = dict(Counter(l))
x = dict(sorted(k.items(), key=lambda kv: (kv[1], kv[0]), reverse=True))
for (i, j) in x.items():
	print(j)
	break


N = int(100.0 + 1)
fr = [0] * N
n = int(input())
a = list(map(int, input().split()))
for item in a:
	fr[item] += 1
print(sorted(fr)[-1])


from collections import Counter
n = int(input())
a = [int(s) for s in input().split()]
print(Counter(a).most_common(1)[0][1])


import math
x = int(input().strip())
y = list(map(int, input().strip().split(' ')))
k = set(y)
h = list(k)
lis = []
for j in h:
	lis.append(y.count(j))
div = int(max(lis))
print(div)


n = int(input())
k = list(map(int, input().split()))
d = set(k)
c = list(d)
l1 = []
for val in range(0, len(c)):
	l1.append(k.count(c[val]))
print(max(l1))


from collections import defaultdict
n = int(input())
arr = list(map(int, input().split()))
maxm = -10 ** 18
freq = defaultdict(int)
for ele in arr:
	freq[ele] += 1
	maxm = max(freq[ele], maxm)
print(maxm)


int(input())
a = input().split()
y = []
for x in a:
	m = a.count(x)
	y.append(m)
print(max(y))


n = int(input())
a = list(map(int, input().split()))
res = max((a.count(x) for x in a))
print(res)


m = input()
m = input().split()
lm = []
for i in range(len(m)):
	lm.append(m.count(m[i]))
print(max(lm))


n = int(input())
l = list(map(int, input().split()))
d = {}
for i in l:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
m = 0
for i in d:
	if d[i] > m:
		m = d[i]
print(m)


from collections import Counter
n = int(input())
a = list(map(int, input().split()))[:n]
b = []
for i in range(0, len(a)):
	b.append(a.count(a[i]))
print(max(b))


from collections import defaultdict
n = int(input())
ls = [int(i) for i in input().split()]
mp = defaultdict(int)
for i in ls:
	mp[i] += 1
print(max(mp.values()))


from collections import defaultdict

def main():
	n = int(input())
	a = list(map(int, input().split()))
	d = defaultdict(int)
	for val in a:
		d[val] += 1
	print(max(d.values()))
main()


input()
a = list(map(int, input().split()))
b = list(set(a))
m = 0
for i in b:
	x = a.count(i)
	if x > m:
		m = x
print(m)


n = int(input())
l = list(map(int, input().split()))
s = list(set(l))
c = 0
for i in range(len(s)):
	t = l.count(s[i])
	if t > c:
		c = t
print(c)


n = int(input())
l = list(map(int, input().split()))
s = []
for i in range(n):
	s.append(l.count(l[i]))
print(max(s))


n = int(input())
arr = list(map(int, input().split()))
dict1 = {}
for i in arr:
	try:
		dict1[i] += 1
	except:
		KeyError
		dict1[i] = 1
print(max(dict1.values()))


n = int(input())
a = list(map(int, input().split()))
rec = [0] * 1000
for i in range(n):
	rec[a[i]] += 1
print(max(rec))


no = int(input())
value = list(map(int, input().split()))
res = [0] * 101
for i in range(no):
	res[value[i]] += 1
res = max(res)
print(res)


n = int(input())
a = input().split()
f = {}
maxf = -1
for i in a:
	t = int(i)
	try:
		x = f[t]
	except:
		x = 0
	f[t] = x + 1
	if f[t] > maxf:
		maxf = f[t]
print(maxf)


n = int(input())
array = list(map(int, input().split()))
count = 1
maxi = 1
array.sort()
i = 0
j = 0
while i < n:
	j = i + 1
	count = 1
	while j < n and array[j] == array[j - 1]:
		j += 1
		count += 1
	if count > maxi:
		maxi = count
	i = j
print(maxi)


n = int(input())
ls = list(map(int, input().split()))
ls.sort()
ans = 1
i = 0
while i < len(ls) - 1:
	cnt = 1
	while ls[i] == ls[i + 1]:
		cnt += 1
		i += 1
		if i == n - 1:
			break
	i += 1
	ans = max(ans, cnt)
print(ans)


n = int(input())
a = sorted(list(map(int, input().split())))
b = [0] * 101
for i in a:
	b[i] += 1
print(max(b))


n = int(input())
q = list(map(int, input().split()))
print(q.count(max(q, key=q.count)))


def max1(a):
	p = a[0]
	for x in a:
		if x > p:
			p = x
	return p

def preobr(x):
	if x % 2 == 1:
		return x + 1
	else:
		return x - 1

def prlist(a):
	for x in a:
		print(x, end=' ')

def dlin(n):
	k = 0
	while n > 0:
		n -= k
		k += 1
	return k - 1
n = int(input())
a = list(map(int, input().split()))
k = 1
for i in range(n):
	p = 0
	for j in range(0, i):
		if a[j] == a[i]:
			p += 1
	if p >= k:
		k += 1
print(k)


n = int(input())
v = 0
one = [i for i in input().split(' ')]
for i in one:
	c = one.count(i)
	v = max(v, c)
print(v)


from collections import defaultdict
n = int(input())
r = defaultdict(int)
for i in map(int, input().split()):
	r[i] += 1
print(max(r.values()))


n = int(input())
coins = [c for c in map(int, input().strip().split())]
slots = [0 for i in range(101)]
max_num_pockets = 0
for c in coins:
	slots[c] += 1
	max_num_pockets = max(slots[c], max_num_pockets)
print(max_num_pockets)


n = int(input())
l = [int(i) for i in input().split()]
from collections import *
c = Counter(l)
print(max((c[i] for i in c)))


n = int(input())
a = input().split()
for i in range(n):
	a[i] = int(a[i])
a.sort()
kq = 1
s = 1
for i in range(1, n):
	if a[i] != a[i - 1]:
		kq = max(kq, s)
		s = 1
	else:
		s += 1
kq = max(kq, s)
print(kq)


a = input()
b = input().split()
max = 0
a = []
for i in range(105):
	a.append(0)
for i in b:
	a[int(i)] += 1
	if a[int(i)] > max:
		max = a[int(i)]
print(max)


a = int(input())
count = [0 for j in range(a)]
b = list(map(int, input().split()))
for i in range(a):
	for j in range(a):
		if b[i] == b[j]:
			count[i] += 1
count.sort()
x = len(count) - 1
print(count[x])


n = int(input())
nums = [int(i) for i in input().split()]
counts = []
for i in nums:
	counts.append(nums.count(i))
print(max(counts))


n = input()
n = int(n)
arr = list(map(int, input().split()))
z = {i: arr.count(i) for i in arr}
out = max(z.values())
print(int(out))


n = int(input())
I = [int(i) for i in input().split()]
I.sort()
(count, M) = (0, [])
for i in range(n):
	count = 1
	if I[i] in I[i + 1:n + 1]:
		for j in range(i + 1, n):
			if I[i] == I[j]:
				count += 1
	M.append(count)
print(max(M))


nums = input().split(' ')
nums = int(nums[0])
ls = []
k = input().split(' ')
ks = sorted(k)
sums = 0
sumx = 0
for i in range(len(ks) - 1):
	if ks[i] == ks[i + 1]:
		sums = ks.count(ks[i])
		ls.append(sums)
	elif ks[i] != ks[i + 1]:
		sumx += 1
ls = sorted(ls)
lss = len(ls)
if len(ls) == 0:
	print('1')
elif len(ls) >= 1:
	print(ls[lss - 1])


def most_frequent(lis):
	return max(set(lis), key=lis.count)
count = 0
number = int(input())
li = list(map(int, input().split()))
lap = most_frequent(li)
for m in li:
	if m == lap:
		count += 1
print(count)


n = int(input())
inputs = input().split(' ')
for i in range(len(inputs)):
	inputs[i] = int(inputs[i])
l = [0] * 100
for i in range(n):
	l[inputs[i] - 1] += 1
max = 0
for i in range(100):
	if l[i] > max:
		max = l[i]
print(max)


n = int(input())
list = [int(x) for x in input().split(' ')]
max = 1
map = {}
for x in list:
	if x in map:
		map[x] += 1
		if map[x] > max:
			max = map[x]
	else:
		map[x] = 1
print(max)


n = int(input())
l = list(map(int, input().split()))
a = [0] * 100
max1 = 0
for i in l:
	a[i - 1] += 1
	if a[i - 1] > max1:
		max1 = a[i - 1]
print(max1)


t = int(input())
l = [int(i) for i in input().split(' ')]
l1 = []
for i in set(l):
	l1.append(l.count(i))
print(max(l1))


from collections import Counter
n = int(input())
coins = Counter(map(int, input().split(' ')))
print(coins.most_common()[0][1])


a1 = input('')
a = int(a1)
b = [int(x) for x in input().split()]
c = set(b)
s = []
for i in c:
	su = 0
	for j in b:
		if i == j:
			su = su + 1
	s.append(su)
print(max(s))


n = int(input())
l = list(map(int, input().split()))
lis = [0] * (max(l) + 1)
for i in l:
	lis[i] += 1
maxi = 0
for i in lis:
	if i > maxi:
		maxi = i
print(maxi)


n = int(input())
a = input()
b = a.split()
for i in range(n):
	b[i] = int(b[i])
ans = {}
for j in range(1, 101):
	for k in range(n):
		if b[k] == j:
			if j not in ans:
				ans[j] = 1
			else:
				ans[j] += 1
max = 0
for o in ans:
	if ans[o] > max:
		max = ans[o]
print(max)


input()
l = input().split()
print(max((l.count(x) for x in l)))


n = int(input())
a = list(map(int, input().split()))
a1 = []
c = [1 for i in range(150)]
for i in a:
	if i not in a1:
		a1.append(i)
	else:
		c[i] += 1
print(max(c))


from collections import defaultdict
n = int(input())
a = [int(x) for x in input().split()]
freq = defaultdict(lambda : 0, {})
for i in a:
	freq[i] += 1
frequencies = []
for k in freq:
	frequencies.append(freq[k])
print(max(frequencies))


n = int(input())
a = list(map(int, input().split()))
dict_of_cnt = {}
for el in a:
	key = el
	dict_of_cnt[el] = a.count(el)
max_cnt = 0
for (key, val) in dict_of_cnt.items():
	if val > max_cnt:
		max_cnt = val
print(max_cnt)


n = int(input())
arr = input().split()
np = 1
for i in arr:
	np = max(np, arr.count(i))
print(np)


n = int(input())
a = list(map(int, input().split()))
k = list(set(a))
g = 0
for i in k:
	h = a.count(i)
	if h > g:
		g = h
print(g)


input()
coins = map(int, input().split(' '))
my_dict = {}
for x in coins:
	my_dict[x] = my_dict.get(x, 0) + 1
print(max(my_dict.values()))


n = int(input())
c = input().split()
maxpock = 0
for i in range(n):
	pocket = 1
	for j in range(n):
		if i != j:
			if c[i] == c[j]:
				pocket += 1
	if pocket > maxpock:
		maxpock = pocket
print(maxpock)


n = int(input())
a = list(map(int, input().split()))
b = set(a)
b = list(b)
k = 1
for i in range(len(b)):
	if a.count(b[i]) > k:
		k = a.count(b[i])
print(k)


n = int(input())
a = [int(i) for i in input().split()]
c = [a.count(i) for i in a]
print(max(c))


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

def most_common(lst):
	return max(set(lst), key=lst.count)
print(coin.count(most_common(coin)))


import sys
import math
fileoperation = 0
if fileoperation:
	orig_stdout = sys.stdout
	orig_stdin = sys.stdin
	inputfile = open('W:/Competitive Programming/input.txt', 'r')
	outputfile = open('W:/Competitive Programming/output.txt', 'w')
	sys.stdin = inputfile
	sys.stdout = outputfile
mod = 1000000007

def nospace(l):
	ans = ''.join((str(i) for i in l))
	return ans
n = int(input())
a = list(map(int, sys.stdin.readline().split(' ')))
s = set(a)
ans = 0
for aa in s:
	ans = max(ans, a.count(aa))
print(ans)
if fileoperation:
	sys.stdout = orig_stdout
	sys.stdin = orig_stdin
	inputfile.close()
	outputfile.close()


n = int(input())
a = list(map(int, input().split()))
di = {}
for i in a:
	if i not in di:
		di[i] = 0
	di[i] += 1
k = sorted(di, key=lambda x: di[x])
print(di[k[-1]])


N = int(input())
C = list(map(int, input().split()))
C.sort()
P = [0 for _ in C]
for c in C:
	for i in range(len(P)):
		if c != P[i]:
			P[i] = c
			break
print(sum(map(lambda x: 1 if x != 0 else 0, P)))


coin_vals = [0] * 100
_n = input()
vals = list(map(int, input().split()))
for val in vals:
	coin_vals[val - 1] += 1
print(max(coin_vals))


n = int(input())
array = list(map(int, input().split()))
result = 1
mx = 1
array.sort()
for i in range(1, len(array)):
	if array[i] == array[i - 1]:
		mx += 1
		if mx > result:
			result = mx
	else:
		mx = 1
print(result)


from sys import stdin
n = int(stdin.readline().rstrip())
nums = list(map(int, stdin.readline().rstrip().split(' ')))
c = [0] * 101
for num in nums:
	c[num] += 1
print(max(c))


input()
coin = sorted(input().split())
current = ['', 0]
Max = 0
for i in coin:
	if i == current[0]:
		current[1] += 1
	else:
		Max = max(current[1], Max)
		current = [i, 1]
print(max(Max, current[1]))


n = int(input())
l = list(map(int, input().split()))
d = {i: 0 for i in range(1, 101)}
mx = 0
for i in l:
	d[i] += 1
	mx = max(d[i], mx)
print(mx)


n = int(input())
lst = list(map(int, input().split()))
ls = list()
for i in range(101):
	ls.append(0)
for i in range(n):
	ls[lst[i]] += 1
print(max(ls))


n = int(input())
a = [int(x) for x in input().split()]
b = []
mini = 0
for i in range(0, 200):
	b.append(0)
for i in range(0, n):
	b[a[i]] += 1
for i in range(0, 200):
	if b[i] > mini:
		mini = b[i]
print(mini)


n = int(input())
a = list(map(int, input().split()))
print(sorted({x: a.count(x) for x in a}.values(), reverse=True)[0])


n = int(input())
a = {}
for i in list(map(int, input().split())):
	if i in a:
		a[i] += 1
	else:
		a[i] = 1
s = 0
for i in a:
	if a[i] > s:
		s = a[i]
print(s)


k = int(input())
a = [int(x) for x in input().split()]
l = []
for i in range(k):
	l.append(a.count(a[i]))
print(max(l))


n = int(input())
x = input()
x = x.split()
count = []
for i in range(0, 101):
	count.append(0)
for i in range(0, n):
	x[i] = int(x[i])
	count[x[i]] = count[x[i]] + 1
print(max(count))


n = int(input())
a = [int(q) for q in input().strip().split()]
b = list(set(a))
ct = -1
for k in b:
	if a.count(k) > ct:
		ct = a.count(k)
print(ct)


n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
len = 1
lenmax = 1
for i in range(1, n):
	if a[i] != a[i - 1]:
		lenmax = max(lenmax, len)
		len = 1
	else:
		len += 1
lenmax = max(lenmax, len)
print(lenmax)


t = int(input())
v = list(map(int, input().split()))
arr = [0] * 101
for i in range(t):
	arr[v[i] - 1] += 1
print(max(arr))


n = int(input())
max = 0
a = list(map(int, input().split()))
for i in range(n):
	s = a.count(a[i])
	if s > max:
		max = s
print(max)


n = int(input())
q = [int(x) for x in input().split()]
print(max([q.count(x) for x in set(q)]))


nMonedas = int(input())
matriz1 = []
monedas = input()
matriz1.append(monedas.split())
contadorMayor = 0
for i in matriz1[0]:
	contador = matriz1[0].count(i)
	if contador > contadorMayor:
		contadorMayor = contador
print(contadorMayor)


n = int(input())
a = list(map(int, input().split(' ')))
l = []
for i in range(n):
	l.append([])
for i in range(len(a)):
	for j in range(n):
		if (a[i] in l[j]) == 0:
			l[j].append(a[i])
			break
l = list(filter(None, l))
print(len(l))


n = int(input())
a = [int(x) for x in input().split()]
mas = [[]]
mas[0].append(a[0])
for i in range(1, len(a)):
	for j in range(len(mas)):
		if a[i] in mas[j]:
			if j == len(mas) - 1:
				vloj = [a[i]]
				mas.append(vloj)
				break
		else:
			mas[j].append(a[i])
			break
print(len(mas))


n = int(input())
pockets = 0
coins = list(map(int, input().split()))
distinct = set(coins)
if len(coins) > len(distinct):
	if min(coins) == max(coins):
		pockets = n
	else:
		while len(coins) != 0:
			for i in distinct:
				coins.remove(i)
			distinct = set(coins)
			pockets += 1
elif len(coins) == len(distinct):
	pockets = 1
print(pockets)


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


from collections import Counter
_ = input()
counter = Counter(input().split())
print(counter.most_common()[0][1])


n = int(input())
line = input().split(' ')
for i in range(n):
	line[i] = eval(line[i])
occurence = []
for i in range(101):
	occurence.append(0)
for i in range(n):
	occurence[line[i]] += 1
maximum = 0
for i in range(101):
	maximum = max(maximum, occurence[i])
print(maximum)


n = int(input())
entrada = str(input())
entrada = entrada.split()
coins = [int(x) for x in entrada]
coins.sort()
counter = 1
values_counter = [1]
for i in range(1, n):
	if coins[i] == coins[i - 1]:
		counter += 1
	else:
		values_counter.append(counter)
		counter = 1
	if i == n - 1:
		values_counter.append(counter)
print(max(values_counter))


N = int(input())
s = input()
s = s.split()
for i in range(N):
	s[i] = int(s[i])
c = []
for i in range(101):
	c.append(0)
for i in range(N):
	c[s[i]] += 1
print(max(c))


total = int(input())
arr = list(map(int, input().split()))
maxi = 0
for i in range(len(arr)):
	temp = arr.count(arr[i])
	if temp > maxi:
		maxi = temp
print(maxi)


from collections import defaultdict

def main():
	noOfTestCases = input()
	l = list(map(int, input().split()))
	d = defaultdict(int)
	for i in l:
		d[i] += 1
	k = max(d.items(), key=lambda x: x[1])
	print(k[1])
main()


n = int(input())
a = [int(s) for s in input().split()]
res = 0
for i in range(max(a) + 1):
	b = a.count(i)
	if b >= res:
		res = b
print(res)


n = int(input())
angka = input().split()
hasil = []
total = 0
if len(angka) > 1:
	for i in angka:
		total = 0
		for j in angka:
			if i == j:
				total += 1
		hasil += [total]
else:
	hasil = [1]
print(max(hasil))


n = input()
arr = list(map(int, input().split()))
arrS = set(arr)
c = 0
for x in arrS:
	y = arr.count(x)
	if y > c:
		c = y
print(c)


COINS = int(input())
ARRAY = list()
SPLIT = input().split(' ')
for i in range(COINS):
	ARRAY.append(int(SPLIT[i]))
COUNT = '1'
ARRAY.sort()
highest_val = 0
for i in range(len(ARRAY)):
	num = ARRAY.count(ARRAY[i])
	if highest_val < num:
		highest_val = num
		COUNT = str(num)
print(COUNT)


from collections import Counter
n = int(input())
A = list(map(int, input().split()))
ans = 0
z = Counter(A)
for i in z:
	ans = max(ans, z[i])
print(ans)


n = int(input())
arr = [int(x) for x in input().split()]
arr.sort()
pocket = 1
i = 0
while i < n:
	j = 0
	count = 0
	while j < n:
		if arr[i] == arr[j]:
			count += 1
		j += 1
	if count > pocket:
		pocket += count - pocket
	i += 1
print(pocket)


t = int(input())
arr = list(map(int, input().split()))
print(max((arr.count(i) for i in arr)))


from sys import stdin, stdout, exit as sys_ret
(f_input, f_print, f_flush) = (stdin.readline, stdout.write, stdout.flush)
Coin = [0 for i in range(128)]
amount = int(f_input())
coins = [int(_) for _ in f_input().split()]
pockets = 1
for i in coins:
	Coin[i] += 1
	pockets = max(pockets, Coin[i])
f_print(str(pockets))


n = int(input())
s = [int(x) for x in input().split()]
m = dict()
for i in range(n):
	m[s[i]] = 0
for i in range(n):
	m[s[i]] += 1
print(max([int(v) for v in m.values()]))


import collections
n = int(input())
arr = list(map(int, input().split(' ')))
d = dict(collections.Counter(arr))
p = 0
zero = [0 for i in range(n)]

def check(dic):
	for i in dic.values():
		if i != 0:
			return 1
	return 0
while check(d):
	for (i, j) in d.items():
		if d[i] >= 1:
			d[i] -= 1
	p += 1
print(p)


y = int(input())
x = list(map(int, input().split()))
v = max(set(x), key=x.count)
f = 0
for i in x:
	if i == v:
		f += 1
print(f)


n = int(input())
m = [int(i) for i in input().split()]
res = []
for i in m:
	res.append(m.count(i))
print(max(res))


input()
coins = list(map(int, input().split()))
x = coins.count
print(max((x(i) for i in list(set(coins)))))


a = int(input())
b = list(map(int, input().split()))
c = [0] * 101
for i in range(len(b)):
	c[b[i]] += 1
print(max(c))


n = int(input())
x = [int(x) for x in input().split()]
freq = {}
p = 1
for num in x:
	if num in freq:
		freq[num] += 1
	else:
		freq[num] = 1
for val in freq:
	if freq[val] > p:
		p = freq[val]
print(p)


import collections
n = int(input())
a = [int(i) for i in input().split()]
d = collections.Counter(a)
print(max(d.values()))


n = int(input())
arr = input().split()
arr = [int(i) for i in arr]
i = 0
cnt = 0
while i < n:
	j = 0
	temp = 0
	while j < n:
		if arr[i] == arr[j]:
			temp += 1
		j += 1
	if temp > cnt:
		cnt = temp
	i += 1
print(cnt, '\n')


n = int(input())
values = [int(n) for n in input().split(' ')]
my_dict = dict(((i, values.count(i)) for i in values))
counter = max(values, key=values.count)
outcome = my_dict[counter]
print(outcome)


n = int(input())
z = list(map(int, input().split()))
z.sort()
max = 1
temp = 1
for i in range(n - 1):
	if z[i] == z[i + 1]:
		temp += 1
	elif temp > max:
		max = temp
		temp = 1
	else:
		temp = 1
if temp > max:
	max = temp
print(max)


n = int(input())
a = list(map(int, input().split()))
b = {}
for i in a:
	if i not in b:
		b[i] = 0
	b[i] += 1
print(max(b.values()))


n = int(input())
a = sorted(list(map(int, input().split())))
m = -1
for i in a:
	m = max(m, a.count(i))
print(m)


n = int(input())
mx = 0
li = list(map(int, input().split()))
f = [0 for _ in range(110)]
for i in li:
	f[i] += 1
	mx = max(mx, f[i])
print(mx)


import sys
import os

def polycarpPockets(coins):
	d = dict()
	for c in coins:
		if c in d:
			d[c] += 1
		else:
			d[c] = 1
	return max(d.values())

def main():
	n = int(input())
	coins = [int(x) for x in input().split()]
	print(polycarpPockets(coins))
main()


d = {}
n = int(input())
data = list(map(int, input().split()))
for el in data:
	if d.get(el) is None:
		d[el] = 0
	d[el] += 1
ans = 1
for el in d.keys():
	ans = max(ans, d[el])
print(ans)


n = int(input())
a = list(map(int, input().split()))
b = []
max = 0
for i in range(n):
	count = 0
	for j in range(n):
		if a[i] == a[j]:
			count += 1
			if count > max:
				max = count
if max > 1:
	print(max)
else:
	print(1)


n = int(input())
list1 = list(map(int, input().split()))
l2 = set(list1)
t = []
for i in l2:
	t.append(list1.count(i))
print(max(t))


import collections
n = int(input())
a = [int(i) for i in input().split()]
d = collections.Counter(a)
m = 1
for i in a:
	if d[i] > 1:
		if d[i] > m:
			m = d[i]
print(m)


n = int(input())
coins = list(map(int, input().split()))
searched = []
coins.sort()
new_max = 0
for i in range(n):
	if coins[i] not in searched:
		max_n = 0
		searched.append(coins[i])
		for coin in coins:
			if coin == coins[i]:
				max_n += 1
		if max_n > new_max:
			new_max = max_n
	else:
		continue
print(new_max)


n = int(input())
x = [int(a) for a in input().strip().split(' ')]
s = set(x)
ans = [x.count(y) for y in s]
print(max(ans))


from collections import defaultdict

def main():
	n = int(input())
	a = map(int, input().split())
	count = defaultdict(lambda : 0)
	for x in a:
		count[x] += 1
	print(max(count.values()))
main()


import sys
import math
import collections

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def get_list():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
import string
for t in range(1):
	n = int(input())
	ans = get_list()
	counter = collections.Counter(ans)
	val = 0
	for i in counter:
		val = max(val, counter[i])
	print(val)


n = input()
c = [0 for i in range(101)]
a = list(map(int, input().split()))
for i in a:
	c[i] += 1
ans = 0
for i in range(101):
	if c[i] > ans:
		ans = c[i]
print(ans)


from collections import Counter
noc = int(input())
coins = [int(x) for x in input().split()]
coinC = Counter(coins)
print(coinC.most_common()[0][1])


n = int(input())
p = input().rstrip().split(' ')
l = []
x = list(set(p))
for i in range(0, len(x)):
	l.append(p.count(x[i]))
print(max(l))


n = int(input())
nums = list(map(int, input().split()))
x = 0
for i in nums:
	if nums.count(i) > x:
		x = nums.count(i)
print(x)


_ = input()
coins = list(map(int, input().split()))
pockets = max([coins.count(c) for c in coins])
print(pockets)


from collections import Counter
n = int(input())
l = [int(x) for x in input().split()]
c = Counter(l)
m = -1
for (i, j) in c.items():
	if j > m:
		m = j
print(m)


n = int(input())
a = map(int, input().split())
b = [0] * 110
for x in a:
	b[x] += 1
print(max(b))


n = input()
l = list(map(int, input().split()))
d = {}
m = []
count = 1
for i in l:
	if len(l) == 1:
		print(1)
		s = True
		break
	elif i in d:
		d[i] += 1
		s = False
		m.append(d[i])
	else:
		d[i] = 1
		s = False
		m.append(d[i])
if s == False:
	print(max(m))


n = int(input())
s = [int(x) for x in input().split()]
L = [0] * 200
for j in range(0, len(s)):
	L[s[j]] = L[s[j]] + 1
print(max(L))


n = int(input(''))
coins = [int(i) for i in str(input('')).split(' ')]
d = {}
for c in coins:
	if c in d.keys():
		d[c] += 1
	else:
		d[c] = 1
print(max(d.values()))


length = int(input())
a = [int(x) for x in input().split()]
arr = []
for i in a:
	arr.append(a.count(i))
print(max(arr))


def counter():
	y = input()
	x = input()
	mylist = []
	myList = x.split()
	frequecieslist = []
	for i in myList:
		frequecieslist.append(myList.count(i))
	print(max(frequecieslist))
counter()


n = int(input())
a = input().split()
b = set(a)
mini = 0
for i in range(len(b)):
	temp = b.pop()
	if a.count(temp) > mini:
		mini = a.count(temp)
print(mini)


from collections import Counter
input()
count = Counter(input().split(' '))
most = count.most_common(1)
print(most[0][1])


n = int(input())
d = dict()
ans = 1
for i in list(map(int, input().split())):
	if i in d.keys():
		d[i] += 1
	else:
		d[i] = 1
	ans = max(ans, d[i])
print(ans)


from collections import Counter
n = int(input())
a = list(map(int, input().split(' ')))

def mode(lst):
	data = Counter(lst)
	return data[data.most_common(1)[0][0]]
print(mode(a))


a = int(input())
l = list(map(int, input().split()))
max = l.count(l[0])
for i in range(a):
	if l.count(l[i]) > max:
		max = l.count(l[i])
print(max)


n = int(input())
nums = list(map(int, input().split()))
ans = 1
for i in set(nums):
	ans = max(ans, nums.count(i))
print(ans)


n = int(input())
coin_list = input().split()
coin_dict = {}
for i in coin_list:
	if i not in coin_dict:
		coin_dict[i] = 1
	elif i in coin_dict:
		coin_dict[i] += 1
v_list = coin_dict.values()
ans = max(v_list)
print(ans)


n = int(input())
arr = [int(x) for x in input().split()]
arr.sort()
c = 1
maxi = 1
for i in range(1, n):
	if arr[i] == arr[i - 1]:
		c += 1
	else:
		if maxi < c:
			maxi = c
		c = 1
if maxi < c:
	maxi = c
print(maxi)


n = int(input())
l = list(map(int, input().split()))
d = {}
for i in l:
	try:
		d[i] += 1
	except:
		d.update({i: 0})
		d[i] += 1
x = list(d.keys())
m = d[x[0]]
for i in range(1, len(x)):
	if d[x[i]] > m:
		m = d[x[i]]
print(m)


n = int(input())
l = list(map(int, input().split()))
dic = {}
for i in l:
	if i in dic:
		dic[i] += 1
	else:
		dic[i] = 1
max = 0
for j in dic:
	if dic[j] > max:
		max = dic[j]
print(max)


y = int(input())
coins = [int(i) for i in input().split()]
large = -1
for i in coins:
	large = max(large, coins.count(i))
print(large)


n = int(input())
l = [int(i) for i in input().split()]
l.sort()
(c, m) = (1, 1)
for i in range(len(l) - 1):
	if l[i] == l[i + 1]:
		c += 1
	else:
		m = max(m, c)
		c = 1
m = max(m, c)
print(m)


n = int(input())
li = list(map(int, input().split()))
cnt = [0] * 101
mx = 0
for i in li:
	cnt[i] = cnt[i] + 1
	if cnt[i] > mx:
		mx = cnt[i]
print(mx)


n = int(input())
a = list(map(int, input().split()))
count = {}
for i in range(1, 101):
	count[i] = 0
for i in a:
	count[i] = count[i] + 1
count_max = count[1]
for i in range(1, 101):
	if count[i] > count_max:
		count_max = count[i]
print(count_max)


n = input()
coins = list(map(int, input().split()))
values = {}
for coin in coins:
	if not coin in values:
		values[coin] = 0
	values[coin] += 1
maxQuant = 0
for quant in values.values():
	if quant > maxQuant:
		maxQuant = quant
print(maxQuant)


import operator
n = int(input())
l = [int(x) for x in input().split()]
d = {}
for i in l:
	if i in d:
		x = d[i]
		d[i] = x + 1
	else:
		d[i] = 1
y = max(d.items(), key=operator.itemgetter(1))[0]
print(d[y])


def pockets(a):
	aa = set(a)
	ca = []
	for i in aa:
		ca.append(a.count(i))
	return max(ca)
n = int(input())
nn = list(map(int, input().split()))
print(pockets(nn))


n = int(input())
L1 = list(map(int, input().split()))
L2 = set(L1[:])
max1 = 0
for i in L2:
	a = L1.count(i)
	if a > max1:
		max1 = a
print(max1)


n = int(input())
a = [int(x) for x in input().split()]
sa = list(set(a))
counts = a.count(sa[0])
for i in range(1, len(sa)):
	if a.count(sa[i]) > counts:
		counts = a.count(sa[i])
	else:
		continue
print(counts)


n = int(input())
a = list(map(int, input().split()))
prop = list(set(a))
dic = {}
for i in prop:
	count = 0
	for j in a:
		if j == i:
			count += 1
	dic[i] = count
emp = []
for (key, value) in dic.items():
	emp.append(value)
print(max(emp))


i1 = int(input())
i2 = input().split()
for i in range(i1):
	i2[i] = int(i2[i])
i2.sort()
mma = 0
cma = 0
no = i2[0]
for x in range(i1):
	if i2[x] == no:
		cma = cma + 1
	else:
		if mma < cma:
			mma = cma
		cma = 1
		no = i2[x]
if mma < cma:
	mma = cma
print(mma)


n = int(input())
massif = [int(a) for a in input().split()]
maxcount = 0
for a in massif:
	x = massif.count(a)
	if x > maxcount:
		maxcount = x
print(maxcount)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def Count_Repeat(List):
	counter = 0
	for i in List:
		curr_frequency = List.count(i)
		if curr_frequency > counter:
			counter = curr_frequency
	return counter
t = inp()
list = inlt()
c = Count_Repeat(list)
print(c)


def count(l, n):
	d = {}
	for i in range(n):
		if l[i] not in d:
			d[l[i]] = 1
		elif l[i] in d:
			d[l[i]] += 1
	max = d[l[0]]
	for i in d:
		if d[i] > max:
			(d[i], max) = (max, d[i])
	return max
a = int(input())
l = list(map(int, input().split()))
print(count(l, a))


n = int(input())
c = list(map(int, input().split()))
print(max([c.count(x) for x in set(c)]))


n = int(input())
a = [int(i) for i in input().split()]
from collections import defaultdict
d = defaultdict(lambda : 0)
for e in a:
	d[e] += 1
print(max(d.values()))


import sys
import math
n = int(input())
lista = [int(x) for x in input().strip().split()]
pro = [0 for i in range(101)]
for i in range(n):
	pro[lista[i]] += 1
print(max(pro))


n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
m = 1
l = -1
s = 0
for i in range(0, n):
	if a[i] == l:
		s += 1
	else:
		m = max(s, m)
		l = a[i]
		s = 1
m = max(s, m)
print(m)


n = int(input())
a = list(map(int, input().split()))
b = {}
for i in a:
	if i in b.keys():
		b[i] += 1
	else:
		b[i] = 1
print(max(b.values()))


a = input()
l = [int(x) for x in input().split()]
y = []
for e in l:
	y.append(l.count(e))
print(max(y))


input()
maps = {}
ar = list(map(int, input().split()))
ans = 0
for a in ar:
	if a in maps:
		maps[a] += 1
	else:
		maps[a] = 1
	ans = max(ans, maps[a])
print(ans)


n = int(input())
a = list(map(int, input().split()))
d = dict()
for i in a:
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
maxi = 0
for i in d:
	maxi = max(maxi, d[i])
print(maxi)


def main():
	n = input()
	vals = [int(v) for v in input().split()]
	d = set(vals)
	print(max((len([c for c in vals if c == k]) for k in d)))
main()


_ = input()
A = list(map(int, input().split()))
bucket = [0] * 101
for a in A:
	bucket[a] += 1
print(max(bucket))


from collections import Counter

def find_pockets(arr):
	ctr = Counter(arr)
	values = list(ctr.values())
	pockets = 0
	while values:
		values = [c - 1 for c in values if c != 0]
		pockets += 1
	print(pockets - 1)
n = input()
arr = list(map(int, input().split()))
find_pockets(arr)


n = int(input())
v = list(map(int, input().split()))
dict1 = {}
for i in v:
	dict1[i] = dict1.get(i, 0) + 1
print(max(dict1.values()))


def answer():
	n = int(input())
	a = [int(x) for x in input().split()]
	c = []
	i = 0
	a.sort()
	while i < len(a):
		targ = a[i]
		j = 0
		homeless = 1
		while j < len(c):
			cell = c[j]
			k = 0
			ruined = 0
			if targ in cell:
				pass
			else:
				cell.append(targ)
				homeless = 0
				break
			j += 1
		if homeless:
			c.append([targ])
		i += 1
	print(len(c))
answer()


a = int(input())
enter = list(map(int, input().rstrip().split()))
count = 0
for i in range(a):
	countnew = 0
	for j in range(i, a):
		if enter[i] == enter[j]:
			countnew += 1
	if count < countnew:
		count = countnew
print(count)


I = input
n = int(I())
coins = I().split()
print(max([coins.count(coin) for coin in coins]))


a = int(input())
coins = list(map(int, input().split()))
count = dict(((str(x), coins.count(x)) for x in set(coins)))
maximum = max(count, key=count.get)
print(count[maximum])


n = int(input())
l = [0] * 101
a = [int(el) for el in input().split()]
for i in range(n):
	l[a[i]] += 1
print(max(l))


n = int(input())
a = list(map(int, input().split()))
ans = 0
maxx = 0
for i in range(0, n):
	x = a[i]
	for j in range(0, n):
		if x == a[j]:
			ans += 1
	maxx = max(ans, maxx)
	ans = 0
print(maxx)


n = int(input())
l = input().split()
li = [int(i) for i in l]
maxa = 0
hashi = dict()
for i in li:
	if i in hashi:
		hashi[i] += 1
	else:
		hashi[i] = 1
for i in hashi:
	maxa = max(maxa, hashi[i])
print(maxa)


n = int(input())
num = [int(c) for c in input().split()]
b = [0]
for i in range(100):
	b.append(0)
for i in range(n):
	b[num[i]] = b[num[i]] + 1
max = 0
for i in range(101):
	if b[i] > max:
		max = b[i]
print(max)


n = int(input())
s = [int(i) for i in input().split()]
e = set()
for i in s:
	e.add(s.count(i))
print(max(e))


n = int(input())
a = str(input())
a = a.split(' ')
copy = []
for i in range(0, n):
	copy.append(0)
	for x in range(0, n):
		if a[i] == a[x]:
			copy[i] += 1
maxcopy = int(0)
for i in range(0, len(copy)):
	if copy[i] > maxcopy:
		maxcopy = copy[i]
print(maxcopy)


n = int(input())
L = [int(e) for e in input().split(' ')]
print(max([L.count(e) for e in L]))


numberCoins = input()
valueCoins = input().split(' ')
largest = 0
for i in range(len(valueCoins)):
	numberValue = valueCoins.count(valueCoins[i])
	if numberValue > largest:
		largest = numberValue
print(largest)


n = int(input())
a = [int(c) for c in input().split(' ')]
dic = {}
for num in a:
	if num not in dic:
		dic[num] = 0
	dic[num] += 1
print(max((dic[num] for num in dic)))


n = int(input(''))
l = input('').split(' ')
g = []
for a in l:
	j = l.count(a)
	g.append(j)
print(max(g))


n = int(input())
a = []
s = str(input()).split(' ')
for i in s:
	a.append(int(i))
numbers = []
for i in range(101):
	numbers.append(0)
for i in a:
	numbers[i] += 1
print(max(numbers))


n = int(input())
a = list(map(int, input().split()))
maxs = 0
for m in a:
	if a.count(m) > maxs:
		maxs = a.count(m)
print(maxs)


n = int(input())
coins = tuple(map(int, input().split()))
result = 0
for i in coins:
	if coins.count(i) > result:
		result = coins.count(i)
print(result)


n = int(input())
arr = [int(i) for i in input().split()]
print(max((arr.count(i) for i in arr)))


z = input
import math
n = int(input())
c = 0
l = list(map(int, z().split()))
p = []
nl = list(set(l))
for i in nl:
	x = l.count(i)
	p.append(x)
print(max(p))


s = int(input())
n = list(map(int, input().split()))
answer = 0
for i in range(101):
	d = n.count(i)
	if d > answer:
		answer = d
print(answer)


n = int(input())
l = [int(i) for i in input().split()]
t = {}
for i in l:
	if i in t:
		t[i] += 1
	else:
		t[i] = 1
print(max(t.values()))


n = int(input())
l = list(map(int, input().split()))
ma = 0
for i in range(n):
	if l.count(l[i]) > ma:
		ma = l.count(l[i])
print(ma)


n = int(input())
v = list(map(int, input().split()))
f = [0 for i in range(0, 101)]
for i in v:
	f[i] = f[i] + 1
print(max(f))


n = int(input())
inp = map(int, input().split())
dict1 = {}
for i in inp:
	n = dict1.get(i, 0)
	dict1[i] = n + 1
print(max(dict1.values()))


input()
a = input().split()
ans = 1
for i in a:
	ans = max(ans, a.count(i))
print(ans)


n = input()
arr = map(int, input().split())
d = {}
for x in arr:
	if x not in d:
		d[x] = 1
	else:
		d[x] += 1
print(max(d.values()))


x = int(input())
m = list(map(int, input().split()))[:x]
ar = []
for i in range(0, x):
	k = m.count(m[i])
	ar.append(k)
print(max(ar))


import collections
d = collections.defaultdict(int)
n = int(input())
lis = list(input().strip().split())
for i in lis:
	d[i] += 1
print(max(d.values()))


n = int(input())
lst = [int(x) for x in input().split()]
lst.sort()
a = 1
b = 0
if n == 1:
	b = 1
for i in range(n - 1):
	if lst[i] == lst[i + 1]:
		a += 1
	b = max(a, b)
	if lst[i] != lst[i + 1]:
		a = 1
print(b)


i = int(input())
x = list(map(int, input().split()))
c = 0
y = 0
x.sort()
for s in range(i - 1):
	if x[s] == x[s + 1]:
		c += 1
	else:
		c = 0
	if c > y:
		y = c
print(y + 1)


n = int(input())
a = list(map(int, input().split()))
b = sorted(a, key=lambda c: a.count(c))
print(b.count(b[-1]))


n = int(input())
mynums = [int(i) for i in input().split()]
a = []
for i in range(101):
	a.append(0)
for i in mynums:
	a[i] += 1
ans = 0
for i in a:
	ans = max(i, ans)
print(ans)