You are given the array a consisting of n elements and the integer k ≤ n.

You want to obtain at least k equal elements in the array a. In one move, you can make one of the following two operations:

  * Take one of the minimum elements of the array and increase its value by one (more formally, if the minimum value of a is mn then you choose such index i that a_i = mn and set a_i := a_i + 1); 
  * take one of the maximum elements of the array and decrease its value by one (more formally, if the maximum value of a is mx then you choose such index i that a_i = mx and set a_i := a_i - 1). 



Your task is to calculate the minimum number of moves required to obtain at least k equal elements in the array.

Input

The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a and the required number of equal elements.

The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9), where a_i is the i-th element of a.

Output

Print one integer — the minimum number of moves required to obtain at least k equal elements in the array.

Examples

Input


6 5
1 2 2 4 2 3


Output


3


Input


7 5
3 3 2 1 1 1 3


Output


4
from __future__ import division, print_function
import bisect
import math
import itertools
import sys
from atexit import register
 
if sys.version_info[0] < 3:
    from io import BytesIO as stream
else:
    from io import StringIO as stream
 
 
if sys.version_info[0] < 3:
    class dict(dict):
        """dict() -> new empty dictionary"""
        def items(self):
            """D.items() -> a set-like object providing a view on D's items"""
            return dict.iteritems(self)
 
        def keys(self):
            """D.keys() -> a set-like object providing a view on D's keys"""
            return dict.iterkeys(self)
 
        def values(self):
            """D.values() -> an object providing a view on D's values"""
            return dict.itervalues(self)
 
    input = raw_input
    range = xrange
 
    filter = itertools.ifilter
    map = itertools.imap
    zip = itertools.izip
 
 
def sync_with_stdio(sync=True):
    """Set whether the standard Python streams are allowed to buffer their I/O.
 
    Args:
        sync (bool, optional): The new synchronization setting.
 
    """
    global input, flush
 
    if sync:
        flush = sys.stdout.flush
    else:
        sys.stdin = stream(sys.stdin.read())
        input = lambda: sys.stdin.readline().rstrip('\r\n')
 
        sys.stdout = stream()
        register(lambda: sys.__stdout__.write(sys.stdout.getvalue()))
 
def main():
    #import bisect
    #i = bisect.bisect_left(a, k)
    #a=[]
    #from sys import stdin
    #input=stdin.readline
            
    #for _ in range (int(input())):
    #n=int(input()) 
    ans=[]
    n,k=map(int, input().split())
    a=list(map(int, input().split()))
    m=max(a)
    a.sort()
    c=[a[0]]
    d=[1]
    for i in range(1,n):
        if a[i]==c[-1]:
            d[-1]+=1
        else:
            c.append(a[i])
            d.append(1)
    #print(c,d)        
    if max(d)>=k:
        print('0')
        exit()
    e=[-1]*(200005)
    j=0
    e[0]=0
    for i in range(len(c)):
           j+=d[i]
           e[c[i]]=j
    for i in range(1,len(e)):
        if e[i]== -1:
            e[i]=e[i-1]
    #print(e)        
    for i in range(1,m+1):
        l=i*2
        need=k-(e[i]-e[i-1])
        o=need
        j=2
        s=1
        c=0
        t=0
        while(l < m ):
            kk=e[min(m,l+j-1)]-e[l-1]
            if kk<need and kk!=0:
                need-=kk
                t+=kk
                c+=(kk*s)
            elif kk==need  and kk!=0:
                t+=kk
                c+=(kk*s)
                break
            elif kk>need  and kk!=0 :
                t+=need
                c+=(need*s)
                break
            j*=2
            s+=1
            l*=2
        if c!=0 and t>=o:
            ans.append(c)    
    #print(ans)
    print(min(ans))
        #YOUR CODE HERE
    
if __name__ == '__main__':
    sync_with_stdio(False)
    main()