You are given an array of integers. Vasya can permute (change order) its integers. He wants to do it so that as many as possible integers will become on a place where a smaller integer used to stand. Help Vasya find the maximal number of such integers.

For instance, if we are given an array $[10, 20, 30, 40]$, we can permute it so that it becomes $[20, 40, 10, 30]$. Then on the first and the second positions the integers became larger ($20&gt;10$, $40&gt;20$) and did not on the third and the fourth, so for this permutation, the number that Vasya wants to maximize equals $2$. Read the note for the first example, there is one more demonstrative test case.

Help Vasya to permute integers in such way that the number of positions in a new array, where integers are greater than in the original one, is maximal.
The first line contains a single integer $n$ ($1 \leq n \leq 10^5$) — the length of the array.

The second line contains $n$ integers $a_1, a_2, \ldots, a_n$ ($1 \leq a_i \leq 10^9$) — the elements of the array.
7
10 1 1 1 5 5 3
4
5
1 1 1 1 1
0
6
300000000 200000000 300000000 200000000 1000000000 300000000
3
10
1 2 3 4 5 6 7 8 9 10
9
1
1
0
7
3 5 2 2 5 2 4
4
5
1 5 4 2 3
4
# f=open('Documents/projects/CPDev/input.txt','r')
# def get_int():return list(map(int,f.readline().split()))
# def get_list(n): return [f.readline().split() for _ in range(n)]
 
def get_list(n): return list(input().split() for _ in range(n))
def get_int():return list(map(int,input().strip().split()))
import math
import bisect
from collections import defaultdict
 
n = get_int()
li=get_int()
 
 
 
def __gcd(a, b):
    if (a == 0):
        return b
    return __gcd(b % a, a)
 
# recursive implementation
def LcmOfArray(arr, idx):
   
    # lcm(a,b) = (a*b/gcd(a,b))
    if (idx == len(arr)-1):
        return arr[idx]
    a = arr[idx]
    b = LcmOfArray(arr, idx+1)
    return int(a*b/__gcd(a,b))
def factorial(x):
    res=1
    for i in range(2, x+1):
        res*=i
    return res
 
di={}
for i in li:
    if i not in di:
        di[i]=0
    di[i]+=1

di=dict(sorted(di.items()))

lis=list(di.keys())
ans=0
for i in li:
    j=bisect.bisect_right(lis, i)

    while j<len(lis) and not di[lis[j]]:
        j+=1

    if j==len(lis):
        continue

    di[lis[j]]-=1
    ans+=1

print(ans)






