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

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())
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))


_ = 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])


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)


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])


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())
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())
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 = 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)