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
# Thank God that I'm not you.

from collections import Counter, deque
import heapq
import itertools
import math
import random
import sys
from types import GeneratorType;

def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
 
    return wrappedfunc 

def primeFactors(n):
    
    counter = Counter(); 
    while n % 2 == 0:
        counter[2] += 1;
        n = n / 2
         
    
    for i in range(3,int(math.sqrt(n))+1,2):
         
        while n % i== 0:
            counter[i] += 1;
            n = n / i
             
    if (n > 2):
        counter[n] += 1;
    
    return counter;

input = sys.stdin.readline;
m = (10**9 + 7)
def mod_inv(n,m):
    n=n%m
    return pow(n,m-2,m)

def nCr(n,r,m):
    numerator=1
    for i in range(r):
        numerator=(numerator*(n-i))%m
    denomenator=1
    for i in range(2,r+1):
        denomenator=(denomenator*i)%m
    return (numerator*mod_inv(denomenator,m))%m






n = int(input())

array = list(map(int, input().split()))


array.sort()

swapped = set()
def bisectLeft(val):
    leftPointer, rightPointer = 0, n - 1
    
    ans = None
    while(rightPointer >= leftPointer):
        middlePointer = (rightPointer + leftPointer) // 2
        
        if array[middlePointer] >= val and middlePointer not in swapped:
            ans = middlePointer
            rightPointer = middlePointer - 1
        else:
            leftPointer = middlePointer + 1
    
    return ans



count = 0

for num in array:
    idx = bisectLeft(num + 1)
    if idx is not None:
        swapped.add(idx)
        count += 1

print(count)                    
             
     