Mishka has got n empty boxes. For every i (1 ≤ i ≤ n), i-th box is a cube with side length a_{i}.

Mishka can put a box i into another box j if the following conditions are met:

  i-th box is not put into another box;  j-th box doesn't contain any other boxes;  box i is smaller than box j (a_{i} < a_{j}). 

Mishka can put boxes into each other an arbitrary number of times. He wants to minimize the number of visible boxes. A box is called visible iff it is not put into some another box.

Help Mishka to determine the minimum possible number of visible boxes!


-----Input-----

The first line contains one integer n (1 ≤ n ≤ 5000) — the number of boxes Mishka has got.

The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9), where a_{i} is the side length of i-th box.


-----Output-----

Print the minimum possible number of visible boxes.


-----Examples-----
Input
3
1 2 3

Output
1

Input
4
4 2 4 3

Output
2



-----Note-----

In the first example it is possible to put box 1 into box 2, and 2 into 3.

In the second example Mishka can put box 2 into box 3, and box 4 into box 1.

Difficulty: EASY

Solutions:
n = int(input())
a = input().split()
for i in range(0, n):
	a[i] = int(a[i])
a.sort()
a.append('x')
y = 1
i = 0
while i < n - 1:
	occ = 1
	while a[i] == a[i + 1]:
		occ += 1
		i += 1
	if occ > y:
		y = occ
	i += 1
print(y)


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


import collections
(h,) = map(int, input().split())
arr = input().split()
cs = collections.Counter(arr)
print(max(cs.values()))


n = int(input())
a = list(map(int, input().split()))
a.sort()
i = 0
max1 = 0
while i < n - 1:
	max2 = 0
	while i < n - 1 and a[i] == a[i + 1]:
		max2 += 1
		i += 1
	i += 1
	max1 = max(max2, max1)
print(1 + max1)


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


_ = input()
a = input().split(' ')
count = 0
while a:
	b = set(a)
	for i in b:
		a.remove(i)
	count += 1
print(count)


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


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


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


n = int(input())
a = list(input().split(' '))
a = [int(i) for i in a]
h = max((a.count(i) for i in a))
print(h)


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


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


import sys
n = int(sys.stdin.readline())
ls = list(map(int, sys.stdin.readline().split()))
count_dict = {}
for i in ls:
	count_dict.setdefault(i, 0)
	count_dict[i] += 1
ls1 = sorted([(k, v) for (k, v) in count_dict.items()], key=lambda x: x[1])
print(ls1[-1][1])


n = int(input().strip())
f = [int(i) for i in input().strip().split(' ')]
max = f.count(f[0])
for i in range(1, n):
	if f.count(f[i]) > max:
		max = f.count(f[i])
print(max)


input()
a = 1
p = 0
for x in sorted(map(int, input().split())):
	if x != p:
		c = 1
		p = x
	else:
		c += 1
		a = max(a, c)
print(a)


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


n = int(input())
boxes = [int(i) for i in input().split()]
boxesnum = []
for box in boxes:
	boxesnum.append(boxes.count(box))
print(max(boxesnum))


import sys
p = {}
n = int(input())
a = [int(i) for i in input().split()]
ans = 0
for i in range(n):
	if a[i] not in p:
		p[a[i]] = 1
	else:
		p[a[i]] += 1
	ans = max(ans, p[a[i]])
print(ans)


n = int(input())
list_val = [int(val) for val in input().split()]
dict_val = {}
for i in range(n):
	dict_val[list_val[i]] = 1 + dict_val.get(list_val[i], 0)
max_val = 0
for (key, val) in dict_val.items():
	max_val = max(max_val, val)
print(max_val)


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


a = int(input())
b = map(int, input().split())
b = sorted(b)
M = dict()
for i in b:
	if i in M.keys():
		M[i] += 1
	else:
		M[i] = 1
b = reversed(b)
ans = 0
for i in b:
	if ans < M[i]:
		ans += M[i] - ans
print(ans)


import os
import sys
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
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')
ALPHA = 'abcdefghijklmnopqrstuvwxyz/'
M = 998244353
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

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

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
n = Int()
a = Counter(array())
print(max(a.values()))


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


import sys
import string
from collections import Counter, defaultdict
from math import fsum, sqrt, gcd, ceil, factorial
from itertools import combinations, permutations
flush = lambda : sys.stdout.flush
comb = lambda x, y: factorial(x) // factorial(y) // factorial(x - y)
ip = lambda : input()
ii = lambda : int(input())
r = lambda : map(int, input().split())
rr = lambda : list(r())
n = ii()
arr = rr()
x = Counter(arr)
print(max(x.values()))


n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
cmax = 0
curnum = 0
cur = 0
for i in a:
	if i == curnum:
		cur += 1
	else:
		if cur > cmax:
			cmax = cur
		cur = 1
		curnum = i
if cur > cmax:
	cmax = cur
print(cmax)


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


n = int(input())
arr = list(map(int, input().split()))
arr.sort()
d = dict()
for i in arr:
	d[i] = d.get(i, 0) + 1
ma = 0
for i in d.keys():
	ma = max(ma, d[i] - 1)
print(ma + 1)


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


input()
src = input()
data = src.split()
ma = {}
for x in data:
	if ma.get(x):
		ma[x] += 1
	else:
		ma[x] = 1
ans = 0
for key in ma:
	ans = max([ans, ma[key]])
print(ans)


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


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


n = int(input())
a = list(map(int, input().split()))
a = sorted(a, key=lambda x: -x)
ans = 0
d = {}
for i in a:
	if i not in d:
		d[i] = 0
	d[i] += 1
for key in d:
	ans = max(ans, d[key])
print(ans)


n = int(input())
array = list(map(int, input().split()))
count = {}
for i in array:
	if i in count:
		count[i] += 1
	else:
		count[i] = 1
max_val = 0
for i in count:
	if count[i] > max_val:
		max_val = count[i]
print(max_val)


n = int(input())
a = [int(i) for i in input().split()]
a.sort()
b = 0
c = 0
setA = set()
for i in range(1, n):
	if a[i] == a[i - 1]:
		c += 1
		if b > 0:
			b -= 1
			n -= 1
	else:
		b += c
		c = 0
		n -= 1
print(n)


n = int(input().strip())
arr = [int(i) for i in input().strip().split(' ')]
s = set(arr)
if len(arr) == len(s):
	print(1)
elif len(s) == 1:
	print(len(arr))
else:
	ans = 0
	dic = {}
	for i in arr:
		if i in dic:
			dic[i] += 1
		else:
			dic[i] = 1
	for i in dic:
		ans = max(ans, dic[i])
	print(ans)


n = int(input())
arr_a = input().split()
arr_a = [int(i) for i in arr_a]
arr_m = {}
for a in arr_a:
	arr_m.update({a: 0})
result = 0
for a in arr_a:
	arr_m[a] += 1
	result = max(result, arr_m[a])
print(result)


n = int(input())
arr = [int(num) for num in input().strip().split()]
arr.sort()
ans = 1
elem = arr[0]
c = 1
for i in range(1, n):
	if arr[i] == elem:
		c += 1
	else:
		ans = max(ans, c)
		elem = arr[i]
		c = 1
ans = max(ans, c)
print(ans)


n = int(input())
s = input()
k = list(map(int, s.split()))
name = []
count = []
for each in k:
	if (each in name) == True:
		count[name.index(each)] += 1
	else:
		name.append(each)
		count.append(1)
print(max(count))


n = int(input())
boxes = [int(x) for x in input().split()]
resp = {}
r = 0
for i in range(n):
	resp[str(boxes[i])] = 0
for i in range(n):
	resp[str(boxes[i])] += 1
	r = max(resp[str(boxes[i])], r)
print(r)


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)


n = int(input())
a = list(map(int, input().split()))
a.sort()
l = []
di = {}
for i in range(n):
	k = a.count(a[i])
	di[a[i]] = k
l = list(di.values())
print(max(l))


def merge(left, right):
	a = []
	left.append(float('Inf'))
	right.append(float('Inf'))
	i = 0
	j = 0
	iters = len(left) + len(right)
	for k in range(iters - 2):
		if left[i] <= right[j]:
			a.append(left[i])
			i += 1
		else:
			a.append(right[j])
			j += 1
	return a

def merge_sort(a):
	mid = int(len(a) / 2)
	if mid > 0:
		left = a[:mid]
		right = a[mid:]
		left = merge_sort(left)
		right = merge_sort(right)
		return merge(left, right)
	return a

def main():
	n = int(input())
	lens = [int(x) for x in input().split()]
	box = 0
	while len(lens):
		s = list(set(lens))
		for i in range(len(s)):
			lens.remove(s[i])
		box += 1
	print(box)
main()


l1 = int(input())
l2 = input().split()
lul = []
obj = {}
for i in range(l1):
	x = l2[i]
	if x in obj:
		obj[x] += +1
	else:
		obj[x] = 1
all_values = obj.values()
max_value = max(all_values)
print(max_value)


n = int(input())
s = input().split()
mx = 0
for x in s:
	t = s.count(x)
	if t > mx:
		mx = t
print(mx)


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


def get_int_list(string):
	ls = []
	sum = ''
	for s in string:
		if s == ' ':
			ls.append(int(sum))
			sum = ''
		else:
			sum += s
	ls.append(int(sum))
	return ls

def get_ans(ls):
	dummy = ls[0]
	count = 0
	max = 0
	for i in ls:
		if dummy == i:
			count += 1
		else:
			if count > max:
				max = count
			dummy = i
			count = 1
	if count > max:
		max = count
	return max
n = int(input())
x = input()
ls = get_int_list(x)
ls = sorted(ls)
print(get_ans(ls))


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


n = int(input())
l = list(map(int, input().split()))
d = {}
l1 = []
for i in l:
	try:
		d[i] += 1
	except KeyError:
		d[i] = 1
for i in d:
	l1.append([i, d[i]])
l1.sort()
l = list(l1)
rem = l[0][1]
for i in range(len(l)):
	rem = max(rem, l[i][1])
print(rem)


n = int(input())
input_list = input().split()
num = []
for i in range(n):
	num.append(int(input_list[i]))
num.sort()
num.append(-1)
ans = 0
cur = 1
for i in range(1, n + 1):
	if num[i] == num[i - 1]:
		cur += 1
	else:
		ans = max(ans, cur)
		cur = 1
print(ans)


n = int(input())
sideLenghts = list(map(int, input().split()))
sides = {}
for num in sideLenghts:
	if num in sides:
		sides[num] += 1
	else:
		sides[num] = 1
nums = 0
while len(sides) != 0:
	temp = list(sides.keys())
	for num in temp:
		sides[num] -= 1
		if sides[num] == 0:
			del sides[num]
	nums += 1
print(nums)


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


n = int(input())
a = list(map(int, input().split()))
a.sort()
d = dict()
for i in range(len(a)):
	try:
		d[a[i]] += 1
	except:
		d[a[i]] = 1
mx = -1
for i in range(len(a)):
	mx = max(mx, d[a[i]])
print(mx)


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


from collections import deque as de
import math
from collections import Counter as cnt

class My_stack:

	def __init__(self):
		self.data = []

	def my_push(self, x):
		return self.data.append(x)

	def my_pop(self):
		return self.data.pop()

	def my_peak(self):
		return self.data[-1]

	def my_contains(self, x):
		return self.data.count(x)

	def my_show_all(self):
		return self.data

	def isEmpty(self):
		return len(self.data) == 0
arrStack = My_stack()

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def get_prime_factors(number):
	prime_factors = []
	while number % 2 == 0:
		prime_factors.append(2)
		number = number / 2
	for i in range(3, int(math.sqrt(number)) + 1, 2):
		while number % i == 0:
			prime_factors.append(int(i))
			number = number / i
	if number > 2:
		prime_factors.append(int(number))
	return prime_factors

def get_frequency(list):
	dic = {}
	for ele in list:
		if ele in dic:
			dic[ele] += 1
		else:
			dic[ele] = 1
	return dic
n = int(input())
a = list(map(int, input().split()))
d = get_frequency(a)
print(d[max(d, key=d.get)])


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


from collections import defaultdict
n = int(input())
arr = list(map(int, input().split()))
dic = defaultdict(int)
for i in arr:
	dic[i] += 1
a = list(dic.keys())
a.sort()
vs = n
prev = dic[a[0]]
for i in a[1:]:
	vs -= min(prev, dic[i])
	prev = max(prev, dic[i])
print(vs)


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


n = int(input())
l = list(map(int, input().split()))
st = []
l.sort()
for i in l:
	if len(st) == 0:
		st.append(i)
	elif i > st[-1]:
		st.pop()
		st.append(i)
	else:
		p = []
		f = 0
		while f == 0 and len(st) > 0:
			if i == st[-1]:
				x = st.pop()
				p.append(x)
			else:
				f = 1
				st.pop()
		while len(p) != 0:
			x = p.pop()
			st.append(x)
		st.append(i)
print(len(st))


n = int(input())
l = input()
lift = l.split()
lift.sort()
cs = 1
ms = 1
for i in range(1, n):
	if lift[i] == lift[i - 1]:
		cs += 1
		ms = max(ms, cs)
	else:
		cs = 1
print(ms)


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


a = int(input())
arr = list(map(int, input().split()))
arr.sort()
d = dict()
for i in arr:
	if i in d:
		d[i] = d[i] + 1
	else:
		d[i] = 1
ans = 0
maxc = -float('inf')
for i in d:
	maxc = max(d[i], maxc)
print(maxc)


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


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


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


n = int(input())
a = list(map(int, input().split()))
at = list(set(a))
max = a.count(at[0])
for j in at:
	if a.count(j) > max:
		max = a.count(j)
print(max)


input()
a = {}
for i in input().split():
	i = int(i)
	if i in a:
		a[i] += 1
	else:
		a[i] = 1
a = sorted(a.items(), key=lambda i: i[0], reverse=True)
b = [i[1] for i in a]
print(max(b))


from collections import Counter

def proC(arr):
	arr.sort(reverse=True)
	dic = Counter(arr)
	for (i, j) in dic.items():
		if i == max(arr):
			ans = j
			continue
		if j <= ans:
			continue
		ans += j - ans
	return ans
n = int(input())
arr = list(map(int, input().split()))
print(proC(arr))


n = int(input())
a = [int(q) for q in input().strip().split()]
b = list(set(a))
max = -1
for k in range(len(b)):
	if a.count(b[k]) > max:
		max = a.count(b[k])
print(max)


import sys
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
maxs = 0
cur = 1
for i in range(1, len(a)):
	if a[i] == a[i - 1]:
		cur += 1
	else:
		maxs = max(cur, maxs)
		cur = 1
maxs = max(cur, maxs)
print(maxs)


import itertools as it
n = int(input())
A = list(map(int, input().split()))
A = sorted(A)
print(max([len(list(x[1])) for x in it.groupby(A)]))


N = int(input())
boxes = sorted(list(map(int, input().split())))
high = 0
for item in boxes:
	high = max(high, boxes.count(item))
print(high)


a = int(input())
b = list(map(int, input().split()))
e = []
for i in range(len(b)):
	c = b.count(b[i])
	e.append(c)
e.sort()
print(e[a - 1])


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


n = int(input())
L = input().split()
for i in range(n):
	L[i] = int(L[i])
S = sorted(L)
A = []
k = 0
a = 1
if n == 1:
	A.append(1)
elif n >= 2:
	for i in range(1, n):
		if S[i] == S[i - 1] and i != n - 1:
			a = a + 1
		elif S[i] != S[i - 1] and i != n - 1:
			A.append(a)
			a = 1
		elif S[i] == S[i - 1] and i == n - 1:
			a = a + 1
			A.append(a)
		elif S[i] != S[i - 1] and i == n - 1:
			A.append(a)
			a = 1
			A.append(a)
S2 = sorted(A)
k = S2[0]
for i in range(1, len(S2)):
	k = k + S2[i] - S2[i - 1]
print(k)


n = int(input())
boxs = input()
boxs = boxs.split(' ')
boxs = [int(size) for size in boxs]

def calculate(boxs):
	boxs.sort()
	count = 0
	before = -1
	now = 0
	for size in boxs:
		if size == before:
			now = now + 1
		else:
			count = max(count, now)
			now = 1
			before = size
	count = max(count, now)
	return count
print(calculate(boxs))


n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
l = 0
while a != [0] * n:
	s = [0]
	for i in range(len(a)):
		if a[i] > s[-1]:
			s.append(a[i])
			a[i] = 0
	l += 1
print(l)


n = int(input())
v = input()
v = list(map(int, v.split()))
resp = 1
r = 1
continua = False
v = sorted(v)
for i in range(n - 1):
	if v[i] == v[i + 1]:
		if continua:
			resp += 1
		else:
			resp = 2
		continua = True
		r = max(r, resp)
	else:
		continua = False
print(r)


def f(A):
	x = 0
	for i in A:
		if A.count(i) > x:
			x = A.count(i)
	return x
n = input()
A = input().split(' ')
print(f(A))


n = int(input())
raw = sorted([int(x) for x in input().split(' ')], reverse=True)
max = 0
for i in range(n):
	c = raw.count(raw[i])
	if c > max:
		max = c
print(max)


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


from collections import Counter
nb = int(input())
lis = list(map(int, input().split()))
di = list(sorted(dict(Counter(lis)).items(), key=lambda x: x[1], reverse=True))
print(di[0][1])


def packing(a):
	a.sort()
	ans = []
	for i in range(len(a)):
		found = False
		if len(ans) > 0 and ans[0] < a[i]:
			ans[0] = a[i]
			ans.sort()
		else:
			ans.append(a[i])
			ans.sort()
	return len(ans)

def ni():
	s = input()
	while len(s) == 0:
		s = input()
	try:
		return int(s)
	except:
		return 0

def nia():
	s = input()
	while len(s) == 0:
		s = input()
	s = s.split()
	iVal = []
	for i in range(len(s)):
		iVal.append(int(s[i]))
	return iVal
n = ni()
print(packing(nia()))


from sys import stdin
from collections import Counter
input = stdin.readline
n = int(input())
a = [int(x) for x in input().split()]
ans = Counter(a).most_common(1)[0][1]
print(ans)


input()
a = input().split()
print(a.count(max(set(a), key=a.count)))


import math

def dict_sort(ans):
	ans = sorted(ans.items(), reverse=True, key=lambda kv: kv[1])

def is_prime(n, k):
	if n == 1:
		return 0
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			res = i
			break
	return res

def inp():
	ls = list(map(int, input().split()))
	return ls
t = int(input())
ls = inp()
s = set(ls)
ans = 0
for i in s:
	ans = max(ans, ls.count(i))
print(ans)


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


n = int(input())
a = [int(i) for i in input().split()]
d = {}
for e in range(len(a)):
	if a[e] not in d:
		d[a[e]] = a.count(a[e])
maxi = -2
b = list(d.keys())
for g in range(len(d)):
	maxi = max(maxi, d[b[g]])
print(maxi)


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


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, k) = (x[0], d[x[0]])
for i in range(1, len(x)):
	if k < d[x[i]]:
		(k, m) = (d[x[i]], x[i])
print(k)


def solve(array):
	temp = list()
	track = dict()
	for i in array:
		if i in track:
			track[i] += 1
		else:
			track[i] = 1
	for (key, values) in sorted(track.items()):
		temp.append(values)
	ans = 0
	extra = 0
	for i in range(len(temp)):
		ans = max(temp[i], ans)
	return ans
t = int(input())
arr = list(map(int, input().split(' ')))
print(solve(arr))


import sys, math, queue, bisect
MOD = 10 ** 9 + 7
sys.setrecursionlimit(1000000)
n = int(input())
a = sorted(map(int, input().split()))
x = []
for ai in a:
	put = False
	for i in range(len(x)):
		if ai > x[i]:
			x[i] = ai
			put = True
			break
	if not put:
		x.append(ai)
print(len(x))


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


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

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

def li():
	return list(mi())
from collections import Counter
n = ii()
a = li()
x = Counter(a).most_common(1)[0][1]
print(x)


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


from collections import Counter
n = int(input())
arr = list(map(int, input().split()))
count = Counter(arr)
sets = list(set(arr))
maxi = -1
for i in range(len(sets)):
	maxi = max(count[sets[i]], maxi)
print(maxi)


def qsort(a, l, r):
	left = l
	right = r
	if r - l > 6:
		piv = a[(l + r) // 2 + 1]
	else:
		piv = a[(l + r) // 2]
	while left < right:
		while a[left] < piv:
			left += 1
		while a[right] > piv:
			right -= 1
		if left <= right:
			tmp = a[left]
			a[left] = a[right]
			a[right] = tmp
			left += 1
			right -= 1
	if l < right:
		qsort(a, l, right)
	if r > left:
		qsort(a, left, r)
n = int(input())
a = [int(i) for i in input().split()]
qsort(a, 0, n - 1)
maxcount = 1
count = 1
for i in range(1, n):
	if a[i] == a[i - 1]:
		count += 1
		if i == n - 1:
			if count > maxcount:
				maxcount = count
	else:
		if count > maxcount:
			maxcount = count
		count = 1
print(maxcount)


n = int(input())
a = [int(x) - 1 for x in input().split()]
d = {}
for i in a:
	if not d.get(i):
		d[i] = 0
	d[i] += 1
print(max(d.values()))


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


x = int(input())
m = list(map(int, input().split()))
k = {}
for i in range(x):
	if m[i] in k:
		k[m[i]] += 1
	else:
		k[m[i]] = 1
d = []
for m in sorted(k):
	d += [[m, k[m], k[m]]]
for i in range(len(d)):
	for j in range(i + 1, len(d)):
		e = d[i][2]
		r = d[j][1]
		if e <= r:
			d[i][2] = 0
			d[j][1] = r - e
			break
		else:
			d[i][2] -= r
			d[j][1] = 0
k = 0
for i in d:
	k += i[1]
print(k)


n = int(input())
lst = list(map(int, input().split()))
d = {}
for (i, x) in enumerate(lst):
	if d.get(x) == None:
		d[x] = 0
	d[x] += 1
print(max(d.values()))


from collections import defaultdict
n = int(input())
arr = list(map(int, input().split()))
dic = defaultdict(int)
for i in arr:
	dic[i] += 1
arr = list(dic.keys())
arr.sort()
_box = dic[arr[0]]
for i in arr[1:]:
	n -= min(_box, dic[i])
	_box = max(_box, dic[i])
print(n)


n = input()
a = list(map(int, input().split()))
aa = set(a)
b = [a.count(x) for x in aa]
print(max(b))


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


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


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


n = int(input())
a = list(map(int, input().split()))
b = []
a.sort()
for i in set(a):
	b.append(a.count(i))
i = 0
while len(b) > 1:
	if b[i] > b[i + 1]:
		b[i + 1] += abs(b[i + 1] - b[i])
	del b[i]
print(b[0])


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


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


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


x = input()
C = [int(m) for m in input().split()]
t = 0
for bam in C:
	if C.count(bam) > t:
		t = C.count(bam)
print(t)


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


from collections import defaultdict
n = int(input())
a = map(int, input().split())
f = defaultdict(int)
for (i, v) in enumerate(a):
	f[v] += 1
print(max(f.values()))


n = int(input())
boxs = input()
boxs = boxs.split(' ')
boxs = [int(size) for size in boxs]
i = 0
j = 1
boxs.sort()
while j < n:
	if boxs[i] < boxs[j]:
		i = i + 1
		j = j + 1
	else:
		j = j + 1
print(j - i)


from sys import *
from collections import *
n = int(stdin.readline())
a = list(map(int, stdin.readline().split()))
a.sort()
b = [a[0]]
for i in range(1, n):
	if a[i] != a[i - 1]:
		b.append(a[i])
cnt = {}
for i in range(len(b)):
	cnt[b[i]] = 0
for i in range(n):
	cnt[a[i]] += 1
b = b[::-1]
ans = cnt[b[0]]
x = cnt[b[0]]
for i in range(1, len(b)):
	if cnt[b[i]] > x:
		ans += cnt[b[i]] - x
		x = cnt[b[i]]
print(ans)


nn = int(input())
d = {}
ss = input().split()
for i in ss:
	i = int(i)
	if i in d:
		d[i] = d[i] + 1
	else:
		d[i] = 1
print(sorted(d.values(), reverse=True)[0])


n = int(input())
ar = list(map(int, input().split()))
ar.sort(reverse=True)
dic = {}
for i in range(n):
	if ar[i] in dic:
		dic[ar[i]] += 1
	else:
		dic[ar[i]] = 1
print(max(list(dic.values())))


import sys
import math
n = int(input())
arr = list(map(int, sys.stdin.readline().split(' ')))
arr.sort()
b = []
current = arr[0]
cnt = 1
ma = 1
for i in range(1, n):
	if arr[i] == current:
		cnt += 1
	else:
		current = arr[i]
		ma = max(ma, cnt)
		cnt = 1
ma = max(ma, cnt)
print(ma)


n = int(input())
boxes = list(map(int, input().split()))
repeats = {}
for box in boxes:
	val = repeats.get(box, 0)
	repeats[box] = val + 1
print(max(repeats.values()))


n = int(input())
list1 = [int(i) for i in input().split()]
list1.sort()
list2 = list(set(list1))
list3 = []
for i in list2:
	list3.append([i, list1.count(i)])
list3.sort()
total = 0
while True:
	for i in list3:
		if i[1] > 0:
			i[1] -= 1
	total += 1
	count = 0
	for i in list3:
		if i[1] == 0:
			count += 1
	if count == len(list3):
		break
print(total)


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


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
print(max(d.values()))


q = int(input(''))
x = dict()
mx = 0
for i in map(int, input('').split(' ')):
	x[i] = x.get(i, 0) + 1
	mx = max(mx, x[i])
print(mx)


import sys
input = sys.stdin.readline
n = int(input())
lst = sorted(list(map(int, input().split())))
(rep, maxRep) = (1, 1)
for i in range(1, n):
	if lst[i] == lst[i - 1]:
		rep += 1
		maxRep = max(maxRep, rep)
	else:
		rep = 1
print(maxRep)


n = int(input())
a = list(map(int, input().split()))
d = {}
for i in range(n):
	if a[i] not in d:
		d[a[i]] = 1
	else:
		d[a[i]] += 1
for i in d:
	prev = d[i]
	break
notfirst = 0
lesser = 0
for i in d:
	if notfirst == 1:
		if d[i] >= prev:
			lesser = max(0, lesser - (d[i] - prev))
		else:
			lesser += prev - d[i]
		prev = d[i]
	else:
		notfirst = 1
print(lesser + d[i])


n = int(input())
A = list(map(int, input().split()))
A.sort()
used = [False] * n
v = n
i = 0
j = 0
while i < n:
	while j < n - 1:
		j += 1
		if A[i] < A[j] and used[j] == False:
			used[j] = True
			v -= 1
			break
	i += 1
print(v)


import sys
(n, v) = (int(input()), [int(x) for x in input().split()])
v = sorted(v, reverse=True)
(pr, i) = (v[0], 0)
b = [1] + [0] * n
for x in v[1:]:
	if x == pr:
		i += 1
		b[i] = 1
	else:
		i = 0
	pr = x
print(b.index(0))


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


from collections import Counter
import operator
n = int(input())
arr = list(map(int, input().split()))
dic = dict(Counter(arr))
sorted(dic.items(), key=operator.itemgetter(1))
dicArr = list(dic.keys())
_box = dic.get(dicArr[0])
for i in dicArr[1:]:
	n -= min(_box, dic[i])
	_box = max(_box, dic[i])
print(n)


n = int(input())
a = [int(z) for z in input().split()]
a.sort()
ks = 0
cs = 0
i = 1
kek = n
while i < kek:
	if a[i] == a[i - 1]:
		cs += 1
		if ks > 0:
			ks -= 1
			n -= 1
	else:
		ks += cs
		cs = 0
		n -= 1
	i += 1
n += 5
print(n - 5)


import sys
sys.setrecursionlimit(6000)

def magick(n):
	global arr
	global arr2
	if len(arr) == 0:
		return
	for i in arr:
		if i > n:
			arr.remove(n)
			magick(i)
			return
	arr.remove(n)
	arr2.append(n)
n = int(input())
arr = list(map(int, input().split(' ')))
arr.sort()
arr2 = []
while True:
	magick(arr[0])
	if len(arr) == 0:
		break
print(len(arr2))


leng = int(input())
arr = list(map(int, input().split()))
d = dict()
ans = 0
for i in arr:
	d[i] = d.get(i, 0) + 1
for v in d.values():
	ans = max(ans, v)
print(ans)


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


n = int(input())
l = list(map(int, input().split()))
l.sort()
l1 = set(l)
l.append(1000000)
l2 = []
for i in l1:
	g = l.index(i)
	for j in range(g, n + 1):
		if l[j] != i:
			q = j
			break
	l2.append(j - g)
print(max(l2))


a = [*open(0)][1].split()
print(max((a.count(x) for x in {*a})))


n = int(input())
a = list(map(int, input().split()))
ans = 0
i = 0
a.sort()
c = []
ans = n
for i in range(n):
	ans1 = a[i]
	if i not in c:
		for j in range(i + 1, n):
			if ans1 < a[j] and j not in c:
				c.append(j)
				ans -= 1
				ans1 = a[j]
print(ans)


import itertools as it
input()
boxes = sorted((int(x) for x in input().split()))
boxes = [list(g) for (k, g) in it.groupby(boxes)]
boxes = list(it.zip_longest(*boxes))
print(len(boxes))


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


n = int(input())
arr = [int(a) for a in input().split()]
arr.sort()
candidate = arr[0]
max_count = 0
count = 0
for l in range(len(arr)):
	if arr[l] == candidate:
		count += 1
	else:
		candidate = arr[l]
		if count > max_count:
			max_count = count
		count = 1
print(max(count, max_count))


def solve():
	n = get(int)
	ar = sorted(get([int]))
	visible = [ar[0]]
	for v in ar[1:]:
		minbox = visible[0]
		if v > minbox:
			heappop(visible)
		heappush(visible, v)
	return len(visible)
_testcases = '\n3\n1 2 3\n\n1\n\n\n4\n4 2 4 3\n\n2\n\n\n5\n1 2 3 3 4\n\n2\n\n\n12\n1 2 3 3 4 4 5 6 6 7 8 8\n\n2\n'.strip()
from bisect import bisect_left, bisect_right
from functools import lru_cache
from heapq import heapify, heappop, heappush
from operator import itemgetter, attrgetter
import bisect
import collections
import functools
import heapq
import itertools
import math
import operator
import re
import string
import sys
inf = float('inf')
cache = lru_cache(None)
sys.setrecursionlimit(10000)

def tree():
	return collections.defaultdict(tree)

def equal(x, y, epsilon=1e-06):
	if -epsilon <= x - y <= epsilon:
		return True
	if -epsilon <= x <= epsilon or -epsilon <= y <= epsilon:
		return False
	return -epsilon <= (x - y) / x <= epsilon or -epsilon <= (x - y) / y <= epsilon

def get(_type):
	if type(_type) == list:
		if len(_type) == 1:
			_type = _type[0]
			return list(map(_type, input().strip().split()))
		else:
			return [_type[i](inp) for (i, inp) in enumerate(input().strip().split())]
	else:
		return _type(input().strip())
printRecursionTree = timeit = lambda x: x
(_p, print) = (print, lambda *a, **b: None)
_p(solve())


n = int(input())
crates = [int(x) for x in input().split()]
dc = {}
for i in crates:
	if i not in dc:
		dc[i] = 0
	dc[i] += 1
print(max(dc.values()))


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

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

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

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

def lcm(a, b):
	return abs(a * b) // math.gcd(a, b)

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)
n = ii()
a = li()
print(max(collections.Counter(a).values()))


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


import heapq as h

def main(n, A):
	S = set(A)
	C = []
	for e in S:
		C.append([e, A.count(e)])
	h.heapify(C)
	l = h.heappop(C)[1]
	while C:
		f = h.heappop(C)[1]
		if f > l:
			l = f
	return l
n = int(input())
A = list(map(lambda n: -int(n), input().split()))
print(main(n, A))


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


n = int(input())
sizes = list(map(int, list(input().split())))
sizes.sort()
most = 1
current = 1
last = 0
for i in sizes:
	if i > last:
		last = i
		current = 1
	else:
		current += 1
		if current > most:
			most = current
print(most)


from bisect import *
n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
a = [-int(x) for x in a]
ans = 0
i = 0
while i < n:
	idx = bisect_right(a, a[i])
	ans = max(ans, idx - i)
	i = idx
print(ans)


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


a = int(input())
list1 = [int(i) for i in str(input()).split()]
list2 = sorted(list1)
list3 = []
w = 1
for i in range(a - 1):
	if list2[i] == list2[i + 1]:
		w += 1
	else:
		list3.append(w)
		w = 1
list3.append(w)
print(max(list3))


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


input()
boxs = list(map(int, input().split()))
boxs_set = list(set(boxs))
boxs_set.sort()
i = 0
for number in boxs_set:
	if boxs.count(number) > i:
		i = boxs.count(number)
print(i)


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


def get_what_to_place(arr):
	mi = 10 ** 10
	mi_idx = -1
	for i in range(len(arr)):
		if arr[i] < mi:
			mi_idx = i
			mi = arr[i]
	return mi_idx

def get_where_to_place(arr, what_to_place_val):
	ma = 10 ** 10
	ma_idx = -1
	for i in range(len(arr)):
		if arr[i] < ma and arr[i] > what_to_place_val:
			ma_idx = i
			ma = arr[i]
	return ma_idx
n = int(input())
outside = list(map(int, input().split()))
inside = outside[:]
for i in range(n):
	what_to_place_idx = get_what_to_place(outside)
	where_to_place_idx = get_where_to_place(inside, outside[what_to_place_idx])
	if what_to_place_idx < 0 or where_to_place_idx < 0 or outside[what_to_place_idx] == 10 ** 10:
		break
	else:
		inside[where_to_place_idx] = inside[what_to_place_idx]
		outside[what_to_place_idx] = 10 ** 10
print(len(list(filter(lambda x: x < 10 ** 10, outside))))


n_boxes = int(input())
box_sizes = input().split()
box_sizes = [int(size) for size in box_sizes]

def count_sizes(box_sizes):
	box_count = []
	last_size = 0
	size_controler = -1
	for size in box_sizes:
		if size == last_size:
			box_count[size_controler] += 1
		else:
			size_controler += 1
			last_size = size
			box_count.append(1)
	return box_count
box_sizes = sorted(box_sizes)
answer = count_sizes(box_sizes)
print(max(answer))


n = int(input())
boxes = list(map(int, input().split(' ')))
boxes = sorted(boxes)
an = [1 for i in range(n)]
pre = boxes[0]
for j in range(1, n):
	now = boxes[j]
	if now == pre:
		an[j] += an[j - 1]
	else:
		an[j] = 1
	pre = now
print(max(an))


N = int(input())
arr = list(map(int, input().split()))
arr.sort()
seq = 0
max_seq = -1
for i in range(len(arr) - 1):
	if arr[i] == arr[i + 1]:
		seq += 1
	else:
		max_seq = max(max_seq, seq)
		seq = 0
print(max(max_seq, seq) + 1)


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


t = int(input())
l = list(input().strip().split(' '))
l1 = set(l)
m = 0
for c in l1:
	m = max(m, l.count(c))
print(m)


n = int(input())
A = [int(i) for i in input().split(' ')]
res = 1
A.sort()
res = 0
for i in A:
	res = max(res, A.count(i))
print(res)


n = int(input())
l = list(map(int, input().split()))
l.sort()
d = {}
d = {l[i]: 0 for i in range(len(l))}
for i in range(len(l)):
	d[l[i]] = d[l[i]] + 1
r = float('-inf')
for j in d:
	r = max(d[j], r)
print(r)


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


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


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


n = int(input())
lst = input().split(' ')
lst = [int(x) for x in lst]
lst.sort()
lst_set = set(lst)
d = {l: 0 for l in lst_set}
for l in lst:
	d[l] += 1
max_m = 0
for key in d:
	if d[key] > max_m:
		max_m = d[key]
print(max_m)


n = int(input())
a = [*map(int, input().split())]
b = list(set(a))
b.sort()
s = [a.count(i) for i in b]
print(max(s))


n = int(input())
a = sorted([int(i) for i in input().split()])[::-1]
times = {i: 0 for i in set(a)}
for i in a:
	times[i] += 1
maxim = 0
for i in times:
	maxim = max(maxim, times[i])
print(maxim)


n = int(input())
boxes = list(map(int, input().split()))
counts = {}
best = 0
for a in boxes:
	counts.setdefault(a, 0)
	counts[a] += 1
	best = max(best, counts[a])
print(best)


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


box = int(input())
numbers = [int(n) for n in input().split()]
numbers.sort()
occu = []
for i in numbers:
	occu.append(numbers.count(i))
occu.sort()
print(occu[-1])


n = int(input())
a = sorted(list(map(int, input().split())))
b = a[:]
i = 0
j = 1
while n > 0 and i < n - 1 and (j < n):
	if a[i] < b[j]:
		b[j] = b[i]
		del a[i]
		del b[i]
		n -= 1
		i = 0
		j = 1
	else:
		j += 1
		if j == n:
			i += 1
			j = i + 1
print(len(a))


n = int(input())
a = []
ans = 0
p = []
a = input().split()
for i in range(n):
	a[i] = int(a[i])
a.sort()
count = 1
for i in range(n - 1):
	if a[i] == a[i + 1]:
		count += 1
	else:
		p.append(count)
		count = 1
p.append(count)
p.sort()
ans = ans + p[0]
for i in range(1, len(p)):
	ans = ans + p[i] - p[i - 1]
print(ans)


n = int(input())
a = list(input().split())
d = dict()
for i in a:
	if i not in d:
		d[i] = 1
	else:
		d[i] += 1
print(max((d[i] for i in d)))


n = int(input())
l = list(map(int, input().rstrip().split(' ')))
l.sort()
m_c = 0
c = 1
la = l[0]
for i in range(1, len(l)):
	if l[i] == la:
		c += 1
	else:
		if c > m_c:
			m_c = c
		c = 1
	la = l[i]
if c > m_c:
	m_c = c
print(m_c)


from collections import Counter
n = int(input())
a = sorted(list(map(int, input().split())))
if all((a[item] < a[item + 1] for item in range(len(a) - 1))):
	print(1)
else:
	print(max(list(Counter(a).values())))


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


n = int(input())
a = sorted(list(map(int, input().split())))
box = [a[-1]]
for i in range(n - 2, -1, -1):
	f = 0
	for j in range(len(box)):
		if a[i] < box[j]:
			box[j] = a[i]
			f = 1
			break
	if f == 0:
		box.append(a[i])
print(len(box))


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


n = int(input())
l = input()
h = []
for i in l.split():
	h.append(int(i))
h.sort()
q = h[n - 1]
t = 0
ne = []
for i in range(n - 1, -1, -1):
	if h[i] == q:
		t += 1
	else:
		ne.append(t)
		t = 1
		q = h[i]
ne.append(t)
print(max(ne))


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


import sys
n = int(input())
a = sorted(map(int, input().split()))
ans = 0
for i in range(n):
	if a[i] == -1:
		continue
	x = a[i]
	a[i] = -1
	for j in range(i + 1, n):
		if x < a[j]:
			x = a[j]
			a[j] = -1
	ans += 1
print(ans)


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


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


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


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


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


import bisect

def list_output(s):
	print(' '.join(map(str, s)))

def list_input(s='int'):
	if s == 'int':
		return list(map(int, input().split()))
	elif s == 'float':
		return list(map(float, input().split()))
	return list(map(str, input().split()))
n = int(input())
a = list(map(int, input().split()))
a.sort()
used = [False] * n
r = n
for i in range(n):
	for j in range(i + 1, n):
		if not used[j] and a[j] > a[i]:
			used[j] = True
			r -= 1
			break
print(r)


n = int(input())
l = list(map(int, input().split()))
l.sort()
i = 0
r = 0
cnt = list()
while i < n - 1:
	if l[i + 1] != l[i]:
		cnt.append(i - r + 1)
		r = i + 1
	i += 1
cnt.append(n - r)
m = len(cnt)
x = cnt[0]
for i in range(1, m):
	x = x + cnt[i] - min(x, cnt[i])
print(x)


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


from sys import stdin, stdout, stderr
import time, math
from collections import defaultdict as dd

def pn(ob):
	stdout.write(str(ob))

def inp():
	return stdin.readline()

def def_value():
	return 0

def process():
	freq = dd(def_value)
	n = int(inp())
	take = 1
	arr = list(map(int, inp().split()))
	for i in arr:
		freq[i] = freq[i] + 1
	for (k, v) in freq.items():
		take = max(take, v)
	print(take)

def main():
	t = 1
	start = time.time()
	while t > 0:
		t -= 1
		process()
	end = time.time()
main()


n = int(input())
b = sorted([int(n) for n in input().split()])
a = []
for i in b:
	a.append(b.count(i))
a.sort()
print(a[-1])


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


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


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


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


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


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


from collections import Counter
l = input()
count = Counter()
list1 = sorted(list(map(int, input().split())))
for item in list1:
	count[item] += 1
print(max(count.values()))


import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math

def main():
	n = int(input())
	a = list(map(int, input().split(' ')))
	print(max(Counter(a).values()))
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')
main()


from queue import SimpleQueue
n = int(input())
a = list(map(int, input().split()))
a = sorted(a)
q = SimpleQueue()
el = a[0]
for i in range(1, len(a)):
	if el == a[i]:
		q.put(a[i])
	elif not q.empty():
		el = q.get()
		q.put(a[i])
	else:
		el = a[i]
total = 1
while not q.empty():
	total += 1
	q.get()
print(total)


n = int(input())
ver = []
ver = input().split(' ')
ma = dict()
for i in ver:
	if i in ma:
		ma[i] = ma[i] + 1
	else:
		ma[i] = 1
max = -1
for (key, value) in ma.items():
	if value > max:
		max = value
print(max)


from sys import stdin, stdout
from collections import Counter

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

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

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
t = ip()
li = ai()
x = max(li)
c = Counter(li).values()
print(max(c))


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


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


n = int(input())
a = list(map(int, input().split()))
a.sort()
res = 0
mp = {}
for i in a:
	mp[i] = mp.get(i, 0) + 1
mx = 0
for (i, v) in sorted(mp.items(), reverse=True):
	res += max(0, v - mx)
	mx = max(mx, v)
print(res)


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


n = list(map(int, input().strip().split()))[0]
arr = list(map(int, input().strip().split()))
count = dict()
for i in arr:
	if i in count:
		count[i] += 1
	else:
		count[i] = 1
maximum = 0
for key in count:
	if count[key] > maximum:
		maximum = count[key]
print(maximum)


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


n = int(input())
my = [n for n in input().split()]
ans = 1
for i in my:
	ans = max(my.count(i), ans)
print(ans)


R = lambda : map(int, input().split())
n = int(input())
a = list(R())
a.sort(reverse=True)
q = [a[0]]
for i in range(1, n):
	if a[i] < q[0]:
		q = q[1:]
	q.append(a[i])
print(len(q))


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


a = int(input())
b = dict()
for i in map(int, input().split()):
	b[i] = b.get(i, 0) + 1
print(max(b.values()))


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


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


def packing(a):
	a.sort()
	ans = []
	for i in range(len(a)):
		found = False
		if len(ans) > 0 and ans[0] < a[i]:
			ans[0] = a[i]
			ans.sort()
		else:
			ans.append(a[i])
			ans.sort()
	return len(ans)

def packing2(a):
	a.sort()
	ans = 1
	last = a[0]
	lastIndex = 0
	for i in range(1, len(a)):
		if a[i] == last:
			continue
		count = i - lastIndex
		if count > ans:
			ans = count
		last = a[i]
		lastIndex = i
	count = len(a) - lastIndex
	if count > ans:
		ans = count
	return ans

def ni():
	s = input()
	while len(s) == 0:
		s = input()
	try:
		return int(s)
	except:
		return 0

def nia():
	s = input()
	while len(s) == 0:
		s = input()
	s = s.split()
	iVal = []
	for i in range(len(s)):
		iVal.append(int(s[i]))
	return iVal
n = ni()
print(packing2(nia()))


n = int(input())
nums = [int(a) for a in input().strip().split()]
large = max(nums)
result_dict = {}
max_count = 0
for i in range(n):
	if nums[i] not in result_dict:
		result_dict[nums[i]] = 1
	else:
		result_dict[nums[i]] += 1
	max_count = max(max_count, result_dict[nums[i]])
print(str(max_count))


n = int(input())
a = [int(x) for x in input().split()]
a.sort(reverse=True)
groups = []
last = a[0]
group = 1
for i in range(1, n):
	if a[i] == last:
		if i == n - 1:
			group += 1
			groups.append(group)
		group += 1
	else:
		groups.append(group)
		group = 1
	last = a[i]
if groups == []:
	print(1)
else:
	print(max(groups))


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


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


n = int(input())
a = [int(c) for c in input().split()]
res = []
for i in range(len(a)):
	res.append(a.count(a[i]))
print(max(res))


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


i = int(input())
x = list(map(int, input().strip().split()))
x.sort()
m = 1
p = x[0]
q = 1
for i in range(1, len(x)):
	if p == x[i]:
		q = q + 1
		if q > m:
			m = q
	else:
		q = 1
		p = x[i]
print(m)


n = int(input())
arr = list(map(int, input().split()))
arr.sort()
dic = {}
for x in arr:
	if x in dic:
		dic[x] += 1
	else:
		dic[x] = 1
cnt = max(dic.values())
print(cnt)


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


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


n = int(input())
list1 = [int(i) for i in input().split()]
list1.sort()
list2 = list(set(list1))
list3 = []
for i in list2:
	list3.append([i, list1.count(i)])
list3.sort()
total = 0
while list3 != []:
	for i in list3:
		if i[1] > 0:
			i[1] -= 1
	total += 1
	temp = []
	for i in list3:
		if i[1] != 0:
			temp.append(i)
	list3 = temp[:]
print(total)


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


n = int(input())
l = list(map(int, input().split()))
e = list(set(l))
e.sort()
m = max(e)
com = 0
e1 = [l.count(i) for i in e]
while len(e1) != 1 and len(e1) != 0:
	com += e1[len(e1) - 1]
	for i in range(0, len(e1)):
		e1[i] -= e1[len(e1) - 1]
	e1 = list(filter(lambda x: x > 0, e1))
if len(e1) == 1:
	com += e1[0]
print(com)


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


n = int(input())
a = list(map(int, input().split()))
a.sort()
p = [0 for i in range(n)]
for i in range(n - 1):
	for j in range(1, n - i):
		if a[i + j] > a[i] and p[i + j] == 0:
			p[i + j] = 1
			p[i] = 2
			break
n = 0
for i in p:
	if i == 1 or i == 0:
		n += 1
print(n)


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


from collections import Counter
n = int(input())
a = [int(i) for i in input().split()]
c = Counter(a)
s = list(sorted(c.items(), key=lambda x: x[0], reverse=True))
ans = 0
bigger_sized_boxes = 0
for (size, number) in s:
	ans += max(number - bigger_sized_boxes, 0)
	bigger_sized_boxes = max(bigger_sized_boxes, number)
print(ans)


n = int(input())
l = list(map(int, input().split()))
l.append(-1)
l = sorted(l)
re = 1
id = 0
for i in range(1, len(l)):
	id = id + 1 if l[i] == l[i - 1] else 0
	re += int(re == id)
print(re)


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


n = int(input())
a = list(map(int, input().split()))
a.sort()
i = 0
b = [0] * n
b[0] = 1
for i in range(n):
	if b[i] == 1:
		for j in range(i + 1, n):
			if b[j] != 1 and a[j] > a[i]:
				b[i] = 0
				b[j] = 1
				break
			elif a[j] == a[i]:
				b[j] = 1
print(sum(b))


n = int(input())
A = list(map(int, input().split()))
dic = dict()
for i in A:
	dic[i] = 0
for i in A:
	dic[i] += 1
X = []
for i in dic:
	X.append(dic[i])
print(max(X))


import sys, os, io
import math, bisect, operator
(inf, mod) = (float('inf'), 10 ** 9 + 7)
from itertools import groupby, accumulate
from heapq import heapify, heappop, heappush
from collections import deque, Counter, defaultdict
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
Neo = lambda : list(map(int, input().split()))
(N,) = Neo()
A = Neo()
print(max(Counter(A).values()))


from collections import OrderedDict
import bisect
n = int(input())
arr = list(map(int, input().split()))
dicta = {}
for a in arr:
	dicta[a] = dicta.get(a, 0) + 1
max_val = max(arr)
dict_keys = list(dicta.keys())
dict_keys.sort()
val = dicta[dict_keys[0]]
ans = n
for _ in range(1, len(dict_keys)):
	ans -= min(val, dicta[dict_keys[_]])
	val = max(val, dicta[dict_keys[_]])
print(ans)


n = int(input())
boxes = list(map(int, input().split()))
counted = set()
mx = 0
for i in range(n):
	if boxes[i] not in counted:
		counted.add(boxes[i])
		c = boxes.count(boxes[i])
		if c > mx:
			mx = c
print(mx)


n = int(input())
c = list(map(int, input().split()))
p = set()
a = []
b = []
for i in c:
	if i in p:
		a[b.index(i)] += 1
	else:
		p.add(i)
		a.append(1)
		b.append(i)
print(max(a))


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


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


def solve(n, seq):
	seq.sort()
	ans = 0
	temp = 0
	prev = seq[0]
	for x in seq:
		if x == prev:
			temp += 1
		else:
			if temp > ans:
				ans = temp
			temp = 1
			prev = x
	if temp > ans:
		ans = temp
	return ans
n = int(input())
seq = list(map(int, input().split()))
print(solve(n, seq))


n = int(input())
a = [int(i) for i in input().split()]
a.sort()
ans = []
for i in a:
	ans.append(a.count(i))
ans.sort()
print(ans[-1])


import math
import collections
n = int(input())
a = [int(x) for x in input().split()]
a.sort()
low = 0
count = 0
d = {}
for i in a:
	if i not in d:
		d[i] = 1
	else:
		d[i] += 1
print(max(list(d.values())))


import math, sys, bisect, heapq, os
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
from functools import lru_cache
int1 = lambda x: int(x) - 1

def input():
	return sys.stdin.readline().rstrip('\r\n')
aj = lambda : list(map(int, input().split()))

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])

def solve():
	(n,) = aj()
	A = aj()
	C = Counter(A)
	maxi = C.most_common(1)
	print(maxi[0][1])
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
solve()


n = int(input())
a = list(map(int, input().split()))
a.sort()
has = [0] * n
isin = [0] * n
for i in range(n - 2, -1, -1):
	if has[n - 1] == 0 and a[i] < a[n - 1]:
		has[n - 1] = i
		n -= 1
print(n)


n = int(input())
skatle = list(map(int, input().strip().split()))
st = dict()
for e in skatle:
	if e not in st:
		st[e] = 0
	st[e] += 1
S = [(s, kol) for (s, kol) in st.items()]
print(max((k for (s, k) in S)))


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


n = input()
dict = {}
l = [int(x) for x in input().split()]
s = set()
for x in l:
	s.add(x)
	try:
		dict[x] = dict[x] + 1
	except:
		dict[x] = 1
mx = 0
for x in dict:
	mx = max(mx, dict[x])
print(mx)


n = int(input())
L = list(map(int, input().split()))
freq = {}
for i in L:
	if i not in freq:
		freq[i] = 0
	freq[i] += 1
m = 0
for j in freq:
	if freq[j] > m:
		m = freq[j]
print(m)


from sys import stdin, stdout

def fin():
	return stdin.readline().strip()

def fout(x):
	stdout.write(str(x) + '\n')
n = fin()
(mp, res) = ({}, 0)
for el in list(map(int, input().split())):
	mp[el] = mp.get(el, 0) + 1
for key in mp:
	res = max(res, mp[key])
fout(res)


from collections import Counter
n = int(input())
cnt = Counter()
arr = [int(i) for i in input().split()]
for i in arr:
	cnt[i] += 1
ans = sum((i[1] for i in cnt.items()))
left = 0
for (i, el) in enumerate(sorted(cnt.items())):
	(num, val) = el
	if i == 0:
		left = val
		continue
	elif val >= left:
		ans -= left
		left = 0
		left += val
	else:
		left -= val
		ans -= val
		left += val
print(ans)


n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
mk = 0
for i in a:
	mk = max(mk, a.count(i))
	a.remove(i)
print(mk)


n = int(input())
l = list(map(int, input().split()))
l.sort(reverse=True)
an = [l[0]]
for i in range(1, n):
	an.sort()
	t1 = -1
	for j in range(len(an)):
		if l[i] < an[j]:
			t1 = j
			break
	if t1 == -1:
		an.append(l[i])
	else:
		an[t1] = l[i]
print(len(an))


n = int(input())
boxes = input().split()
result = 0
while len(boxes) > 0:
	unique = set(boxes)
	for box in unique:
		boxes.remove(box)
	result += 1
print(result)


import collections
n = int(input())
nums = list(map(int, input().split()))
d = collections.defaultdict(int)
for i in nums:
	d[i] += 1
k = sorted(d.keys())
if len(k) == 1:
	print(d[k[0]])
	exit()
t = d[k[0]]
s = 0
for i in range(1, len(k)):
	in_boxes = min(d[k[i]], t)
	t = t + d[k[i]] - in_boxes
	s += in_boxes
print(n - s)


def mergeSort(inp):
	if len(inp) > 1:
		mid = len(inp) // 2
		lefthalf = inp[:mid]
		righthalf = inp[mid:]
		mergeSort(lefthalf)
		mergeSort(righthalf)
		i = 0
		j = 0
		k = 0
		while i < len(lefthalf) and j < len(righthalf):
			if lefthalf[i] < righthalf[j]:
				inp[k] = lefthalf[i]
				i = i + 1
			else:
				inp[k] = righthalf[j]
				j = j + 1
			k = k + 1
		while i < len(lefthalf):
			inp[k] = lefthalf[i]
			i = i + 1
			k = k + 1
		while j < len(righthalf):
			inp[k] = righthalf[j]
			j = j + 1
			k = k + 1
nums = int(input())
inp = input().split(' ', nums - 1)
for i in range(len(inp)):
	inp[i] = int(inp[i])
mergeSort(inp)
maximum = 1
currmax = 1
currbase = inp[0]
for i in range(1, len(inp)):
	if inp[i] == currbase:
		currmax = currmax + 1
	else:
		currbase = inp[i]
		if maximum < currmax:
			maximum = currmax
		currmax = 1
if maximum < currmax:
	maximum = currmax
print(maximum)


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


n = int(input())
box = dict()
maxbox = 0
for i in input().split():
	a = int(i)
	if box.get(a) == None:
		box[a] = 1
	else:
		box[a] += 1
	if maxbox < box[a]:
		maxbox = box[a]
print(maxbox)


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


from collections import defaultdict
from sys import stdin
n = int(input())
d = defaultdict(lambda : 0)
arr = list(map(int, stdin.readline().rstrip().split(' ')))
for ele in arr:
	d[ele] += 1
print(max(d.values()))


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


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


k = int(input())
ans = []
a = list(map(int, input().split()))
a.sort()
for i in a:
	ans.append(a.count(i))
ans.sort()
ans.reverse()
print(ans[0])


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


n = int(input())
size = input().split()
sett = set(size)
list = []
for i in sett:
	list.append(size.count(i))
list.sort()
print(list[-1])


bcnt = int(input())
boxs = list(map(int, input().strip().split()))
boxs.sort()
chk = [0 for _ in range(bcnt)]
cnt = 0
while True:
	isWork = False
	for i in range(bcnt):
		for j in range(i + 1, bcnt):
			if boxs[i] < boxs[j] and chk[i] != 1 and (chk[j] != 2):
				chk[i] = 1
				chk[j] = 2
				isWork = True
				cnt += 1
	if not isWork:
		break
print(bcnt - cnt)


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


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


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


x = int(input())
y = input()
y = y.split()
if len(y) == x:
	y = sorted(y, key=y.count, reverse=True)
	print(y.count(y[0]))


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


n = int(input())
l1 = list(map(int, input().split()))
d1 = {}
for item in l1:
	if item not in d1:
		d1[item] = 1
	else:
		d1[item] += 1
ans = 0
for k in d1:
	ans = max(ans, d1[k])
print(ans)


n = int(input())
a = list(map(int, input().split()))
s = sorted(list(set(a)))
w = {}
for i in range(len(s)):
	w[s[i]] = a.count(s[i])
res = w[s[-1]]
print(max(w.values()))


import sys
n = int(input())
sides = list(map(int, input().split()))
in_another_box = [False] * n
sides.sort()
index = 0
for i in range(n):
	while index < len(sides) and sides[i] >= sides[index]:
		index += 1
	if index < len(sides):
		in_another_box[i] = True
		index += 1
print(in_another_box.count(False))


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


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


def numVisible(boxes):
	ht = {}
	for b in boxes:
		ht.setdefault(b, 0)
		ht[b] += 1
	return max(ht.values())
_ = int(input())
boxes = [int(x) for x in input().split()]
print(numVisible(boxes))


x = int(input())
a = input().split()
h = []
for i in a:
	h.append(a.count(i))
h.sort()
print(h[-1])


num = int(input())
count = dict()
max_count = 0
for num_str in input().split():
	num = int(num_str)
	if num in count:
		count[num] += 1
	else:
		count[num] = 1
	if count[num] > max_count:
		max_count = count[num]
print(max_count)


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


n = int(input())
l = sorted([int(i) for i in input().split()], reverse=True)
c = 0
c1 = 1
for i in range(1, n):
	if l[i] != l[i - 1]:
		c = max(c1, c)
		c1 = 1
	else:
		c1 += 1
c = max(c1, c)
print(c)


def f1(arr):
	ans = []
	for i in arr:
		if i != 0:
			ans.append(i)
	return ans

def f2(arr):
	ans = []
	for i in arr:
		ans.append(i - 1)
	return ans
from itertools import groupby
n = int(input())
a = [int(x) for x in input().split()]
b = a[:]
b.sort()
c = [len(list(group)) for (key, group) in groupby(b)]
ans = 0
while len(c) > 1:
	ans = ans + 1
	c = f2(c)
	c = f1(c)
if len(c) != 0:
	ans = ans + c[0]
print(ans)


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


import math
n = int(input())
lst = list(map(str, input().strip().split(' ')))
l = list(dict.fromkeys(lst))
m = 0
for j in range(len(l)):
	c = lst.count(l[j])
	if c > m:
		m = c
print(m)


from sys import stdin

def main():
	n = int(stdin.readline())
	ar = list(map(int, stdin.readline().split()))
	ar.sort()
	check = [False] * n
	for i in range(1, n):
		for j in range(i - 1, -1, -1):
			if ar[j] < ar[i] and (not check[j]):
				check[j] = True
				break
	ans = 0
	for i in range(n):
		if not check[i]:
			ans += 1
	print(ans)
main()


boxes = int(input())
string = input().split()
boxesLen = {}
for i in range(boxes):
	boxesLen[string[i]] = boxesLen.get(string[i], 0) + 1
print(boxesLen[max(boxesLen, key=boxesLen.get)])


from collections import Counter
mp = Counter()
n = int(input())
arr = list(map(int, input().split()))
mx = 0
for i in arr:
	mp[i] += 1
	mx = max(mp[i], mx)
print(mx)


n = int(input())
l = [int(i) for i in input().split()]
l = sorted(l)
result = 1
cur = -1
count = 0
for i in l:
	if i == cur:
		count += 1
	else:
		cur = i
		result = max(result, count)
		count = 1
result = max(result, count)
print(result)


n = int(input())
a = list(map(int, input().split()))
a.sort(reverse=True)
k = 0
for i in range(n - 1):
	k = max(k, a.count(a[i]))
if n == 1:
	print(1)
else:
	print(k)


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
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')
n = int(input())
a = list(map(int, input().split()))
a.sort()
d = dict()
c = 1
for i in range(n):
	if a[i] not in d:
		d[a[i]] = 1
	else:
		d[a[i]] += 1
for i in range(n):
	c = max(c, d[a[i]])
print(c)


n = int(input())
lst = []
for x in input().split():
	lst.append(int(x))
d = {}
for x in lst:
	if not x in d:
		d[x] = 0
	d[x] += 1
print(max(d.values()))


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


(n, a) = (input(), list(map(int, input().split())))
c = {i: a.count(i) for i in a}
print(max(c.values()))


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


hold = {}
n = int(input())
folder = input().split()
for i in range(n):
	x = int(folder[i])
	if x in hold:
		hold[x] += 1
	else:
		hold[x] = 1
shold = list(hold.values())
shold.sort()
u = len(shold) - 1
print(shold[u])


from collections import Counter
t = int(input())
l1 = list(map(int, input().split()))
v = list(Counter(l1).values())
b = True
j = 0
while b:
	b = False
	j += 1
	for i in range(len(v)):
		if v[i] != 0:
			v[i] -= 1
			b = True
print(j - 1)


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


n = int(input())
arr = list(map(int, input().split()))
arr.sort()
prv = ans = 0
tmp = 1
for item in arr:
	if item == prv:
		tmp += 1
	else:
		tmp = 1
	ans = max(ans, tmp)
	prv = item
print(ans)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
n = int(input())
mp = {}
mx = 0
F = [0] * 5009
F = list(map(int, input().split()))
for i in range(n):
	x = F[i]
	val = mp.get(x)
	if val == None:
		val = 0
	mp[x] = val + 1
	if val + 1 > mx:
		mx = val + 1
print(mx)


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


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


import operator
n = int(input())
d = dict()
for i in map(int, input().split()):
	if i in d:
		d[i] += 1
	else:
		d[i] = 1
print(max(d.items(), key=operator.itemgetter(1))[1])


import sys

def main():
	n = int(sys.stdin.readline().strip())
	li = list(map(int, sys.stdin.readline().split()))
	d = dict()
	for x in li:
		if x not in d.keys():
			d[x] = 1
		else:
			d[x] += 1
	print(max(d.values()))
main()


n = int(input())
box = [int(i) for i in input().split()]
box.sort()
box.reverse()
box1 = list(set(box))
box1.reverse()
l = []
for i in box1:
	l.append(box.count(i))
print(max(l))


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


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