Natasha is planning an expedition to Mars for $n$ people. One of the important tasks is to provide food for each participant.

The warehouse has $m$ daily food packages. Each package has some food type $a_i$.

Each participant must eat exactly one food package each day. Due to extreme loads, each participant must eat the same food type throughout the expedition. Different participants may eat different (or the same) types of food.

Formally, for each participant $j$ Natasha should select his food type $b_j$ and each day $j$-th participant will eat one food package of type $b_j$. The values $b_j$ for different participants may be different.

What is the maximum possible number of days the expedition can last, following the requirements above?


-----Input-----

The first line contains two integers $n$ and $m$ ($1 \le n \le 100$, $1 \le m \le 100$) — the number of the expedition participants and the number of the daily food packages available.

The second line contains sequence of integers $a_1, a_2, \dots, a_m$ ($1 \le a_i \le 100$), where $a_i$ is the type of $i$-th food package.


-----Output-----

Print the single integer — the number of days the expedition can last. If it is not possible to plan the expedition for even one day, print 0.


-----Examples-----
Input
4 10
1 5 2 1 1 1 2 5 7 2

Output
2

Input
100 1
1

Output
0

Input
2 5
5 4 3 2 1

Output
1

Input
3 9
42 42 42 42 42 42 42 42 42

Output
3



-----Note-----

In the first example, Natasha can assign type $1$ food to the first participant, the same type $1$ to the second, type $5$ to the third and type $2$ to the fourth. In this case, the expedition can last for $2$ days, since each participant can get two food packages of his food type (there will be used $4$ packages of type $1$, two packages of type $2$ and two packages of type $5$).

In the second example, there are $100$ participants and only $1$ food package. In this case, the expedition can't last even $1$ day.

Difficulty: interview

Starter code:

Solutions:
n, k = map(int, input().split())
a = list(map(int, input().split()))
day = 1
def poss(day):
	q = 0
	mp = dict()
	for el in a:
		if el not in mp:
			mp[el] = 1
		else:
			mp[el] += 1
	for el in mp:
		q += mp[el] // day
	return q >= n

while poss(day):
	day += 1

print(day - 1)

n,m = list(map(int,input().split()))
linp = list(map(int,input().split()))

l = [0]*101
for i in linp:
    l[i] += 1

test = 100
while test > 0:
    l2 = [i//test for i in l]
    peop = sum(l2)
    if peop >= n:
        break
    else:
        test -= 1

print(test)


n, m = list(map(int, input().split()))
d = {}
s = list(map(int, input().split()))
for c in s:
    if c in d:
        d[c] += 1
    else:
        d[c] = 1

d = list(d.values())

for k in range(m, 0, -1):
    l = 0
    for v in d:
        l += v // k
        if l >= n:
            print(k)
            return
print(0)


n, m = list(map(int, input().split()))
a = [0] * 100
inp = list(map(int, input().split()))

for i in inp:
    a[i - 1] += 1
    
go = True
ans = 0
for i in range(1000):
    
    b = [i for i in a]
    
    cnt = 0
    for j in b:
        cnt += j // (i + 1)
        
    go = cnt >= n
    
    if not go:
        ans = i
        break
print(i)


from collections import defaultdict as dd, deque

n,m = list(map(int,input().split()))
A = [int(x) for x in input().split()]

C = dd(int)
for a in A:
    C[a] += 1

psize = 1
while True:
    packs = 0
    for c in C:
        packs += C[c]//psize
    if packs < n: # Previous possible, this one not
        break
    psize += 1
print(psize - 1)



from collections import Counter

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

C = Counter(a)


def check(p):
    return sum(el // p for el in list(C.values())) >= n


def binSearch(a, b):
    left, right = a - 1, b + 1

    while right - left > 1:
        mid = (left + right) // 2

        if check(mid):
            left = mid

        else:
            right = mid

    return left


print(binSearch(1, 100))


import sys
import os

def test(food, n, day):
    p = 0
    for i in food:
        p += i // day
    return p >= n

def solve(package, n):
    food = dict()
    for f in package:
        if f in food:
            food[f] += 1
        else:
            food[f] = 1

    r = list(food.values())

    left = 0
    right = 1000
    while right > left + 1:
        mid = (left + right) // 2
        if test(r, n, mid):
            left = mid
        else:
            right = mid

    return left


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

def __starting_point():
    main()
__starting_point()

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

# print(d)

mx = m // n

while mx != 0:
    cur = 0
    for i in d:
        t = d[i] // mx
        cur += t
    if cur >= n:
        break
    else:
        mx -= 1

print(mx)

n,m=map(int,input().split())
arr=list(map(int,input().split()))
d={}
for i in arr:
  if i in d.keys():
    d[i]+=1
  else:
    d[i]=1
days=1
while True:
  count=0
  for i in d.keys():
    count+=d[i]//days 
  if count<n:
    break 
  days+=1
print(days-1)

from collections import Counter


def read():
    return int(input())


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


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


n, m = readmap()
A = readlist()
c = Counter(A)
freq = []
for v in c.values():
    freq.append(v)
freq.sort(reverse=True)


def ok(i):
    j = n
    for f in freq:
        j -= f // i
    if j <= 0:
        return True
    else:
        return False


for i in reversed(range(1, m+1)):
    if ok(i):
        print(i)
        quit()

print(0)

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

for i in a:
    if i in c:
        c[i] += 1
    else:
        c[i] = 1

c = sorted(list(c.values()))

def check(p):
    d = c[:]
    for _ in range(n):
        while d and d[-1] < p:
            del d[-1]
        if not d:
            return False
        d[-1] -= p
    return True

for k in range(m, -1, -1):
    if check(k):
        print(k)
        break
else:
    print(0)


n, m = list(map(int, input().split()))
N = list(map(int, input().split()))
A = [0] * 100
for i in range(m):
    A[N[i] - 1] += 1
X = [0] * 100
f = 0
r = 100000
g = 0
for i in range(n):
    f = 0
    for k in range(100):
        if A[k] // (X[k] + 1) > f:
            f = A[k] // (X[k] + 1)
            g = k
    X[g] += 1
    r = min(r, A[g] // X[g])
print(r)
            


n,m=map(int,input().strip().split())
l=list(map(int,input().strip().split()))
l1=[0 for i in range(101)]
for i in l:
    l1[i]=l1[i]+1
for i in range(100,0,-1):
    r=0
    for j in range(1,101):
        r=r+l1[j]//i
    if (r>=n):
        print (i)
        return
print (0)

def check(x):
    ans = 0
    for i in range(101):
        ans += cnt[i] // x
    return ans >= n


n, m = map(int, input().split())
a = list(map(int, input().split()))
cnt = [0] * 101
for elem in a:
    cnt[elem] += 1
l = 0
r = m + 1
while r - l > 1:
    mid = (r + l) // 2
    if not check(mid):
        r = mid
    else:
        l = mid
print(l)

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

cnt = [0 for _ in range(101)]
for ai in a:
    cnt[ai] += 1
l = 0
r = 101
while l + 1 < r:
    c = (l + r) // 2
    k = 0
    for i in range(1, 101):
        k += cnt[i] // c
    if n <= k:
        l = c
    else:
        r = c
print(l)


n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
cnt=[0]*101
for i in a:
    cnt[i]+=1
cnt.sort(reverse=True)
ans=0
for i in range(1,101):
    k=0
    for j in range(101):
        k+=cnt[j]//i
        if k>=n:
            ans=max(ans,i)
            break
print(ans)
            


from collections import defaultdict

n, m = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
food = [0 for i in range(101)]
users = [0 for i in range(101)]

for i in x:
    food[i] += 1
days = 1000
for i in range(n):
    best = 0
    cand = -1
    for j in range(101):
        if (food[j] // (users[j] + 1)) > best:
            best = food[j] // (users[j] + 1)
            cand = j
    users[cand] += 1
    days = min(days, best)

print(days)


from collections import Counter
n, m  = list(map(int, input().split()))

b = Counter(list(map(int, input().split())))

# print(b.values())

res = 0
for days in range(1, m//n +1 ):
    parts = 0
    for j  in list(b.values()):
        parts += j // days
    if parts >= n:
        res = days

print(res)










d = {}

s = input().split()
n = int(s[0])
m = int(s[1])

s = input().split()

for item in s:
    if item not in d.keys():
        d.update(dict([(item, 1)]))
    else:
        d[item] += 1

cur = 0

while True:
    num = 0
    for item in d.values():
        num += item // (cur + 1)
    if num < n:
        break
    cur += 1

print(cur)

m,n=input().strip().split(' ')
m,n=int(m),int(n)
arr=list(map(int,input().strip().split(' ')))
days=0
if(m>n):
    print(0)
else:
    mp={}
    for i in arr:
        if(i in mp):
            mp[i]+=1
        else:
            mp[i]=1
    temp=[]
    for i in mp:
        temp.append(mp[i])
    temp.sort()
    days=0
    j=1
    #print(temp)
    while(1):
        cnt=0
        #print(j)
        for i in temp:
            cnt+=i//j
            if(cnt>=m):
                break
        if(cnt<m):
            break
        days+=1
        j+=1
    print(days)


n, m = list(map(int, input().split()))
c = list(map(int , input().split()))
m = max(c)
a = []
for i in range(m+1):
    a.append(c.count(i))
p = [0]*(m+1)
curmax = 10**9
for i in range(n):
    ind = 0
    best_result = 0
    for j in range(m+1):
        current_result = 10**9
        for k in range(m+1):
            mn = p[k]
            if k == j:
                mn += 1
            if mn == 0:
                continue
            current_result = min(current_result, a[k]//mn)
        if current_result > best_result:
            best_result = current_result
            ind = j
    p[ind] += 1
ans = 10**9
for i in range(m+1):
    if p[i] > 0:
        ans = min(ans, a[i]//p[i])
print(ans)


n,m=list(map(int,input().split()))
s=list(map(int,input().split()))
d=dict()
for i in s:
    try:
        d[i]+=1
    except:
        d.update({i:1})
s1=[]
for i in d:
    s1.append(d[i])
s1.sort()
ans=0
for i in range(1, 101):
    t=s1.copy()
    x=0
    while len(t)>0 and x!=n:
        if t[-1]<i:
            t.pop()
        else:
            t[-1]-=i
            x+=1
    if x==n:
        ans=max(ans,i)
        
print(ans)


n, m = list(map(int, input().split()))
a = [int(el) for el in input().split()]
b = [0] * 101
for i in range(m):
    b[a[i]] += 1
d = []
for i in b:
    if i != 0:
        d.append([i, 0])


def f(df):
    return -df[0]


d.sort(key = f)


k = 0
l = 0
for i in range(n):
    nm = 0
    mm = d[0][0] // (d[0][1] + 1)
    for j in range(len(d)):
        if mm < d[j][0] // (d[j][1] + 1):
            nm = j
            mm = d[j][0] // (d[j][1] + 1)
    d[nm][1] += 1
print(mm)