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: interview

Starter code:

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

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())
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 collections import Counter

n = int(input())
a = list(map(int, input().split()))
c = Counter(a)
print(c.most_common(1)[0][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])

N = int(input())
boxes = sorted(list(map(int,input().split())))

high = 0
for item in boxes:
    high = max(high, boxes.count(item))

print(high)


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

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)

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)

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)

from collections import Counter

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

print(max(list(Counter(a).values())))


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)

'''
2 3 4 2 3 4
1 1 1 2 2 2
'''


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)

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)



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

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

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())
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())
l = list(map(int, input().split()))

ans = 0
for k in l :
  ans = max(l.count(k), ans)
print(ans)


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

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

print(a.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()))