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

Solution (in JAVA):

Solution:
import java.util.*;
   import java.io.*;
 public class Solution {
     static ArrayList<Integer> graph[];
     static int parent[];
     static boolean vis[];
     static int seive[]=new int[1000001];
     static int dis[]=new int[1000001];
     static int subtree[]=new int[1000001];
     static int N =1000001;
     static HashSet<String> hm=new HashSet<>();
   static HashSet<String> hm1=new HashSet<>();
     static int time=0;
     public static void main(String[] args) {
       Scanner sc = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
       StringBuilder sb=new StringBuilder();
       int n=sc.nextInt();
       int k=sc.nextInt();
       long a[]=new long[n];
       for( int i=0;i<n;i++)
       {
         a[i]=sc.nextLong();
       }
       PriorityQueue<Long> count[]=new PriorityQueue[200001];
       for( int i=0;i<200001;i++)
       {
         count[i]=new PriorityQueue<>(Collections.reverseOrder());
       }
       for( int i=0;i<n;i++)
       {
         long x=a[i];
         long op=0;
         count[(int)x].add(op);
         if(count[(int)x].size()>k)
         {
           count[(int)x].remove();
         }
         while(x>0)
         {
           x/=2;
           op++;
           count[(int)x].add(op);
           if(count[(int)x].size()>k)
           {
             count[(int)x].remove();
           }
         }
        
       }
       long min=Integer.MAX_VALUE;
       for( int x=0;x<200001;x++)
       {
                    long sum=0;
         if(count[x].size()<k)
         continue;
         else
         {

           while(count[x].size()>0)
           {
             sum+=count[x].remove();
           }
         }
         min=Math.min(min, sum);
       }
       System.out.println(min);



}
}

class Pair
{
long x,y;
Pair(long x, long y)
{
this.x=x;
this.y=y;
}
}
class myComparator implements Comparator<Pair>
{
public int compare(Pair a, Pair b)
{
return Long.compare(b.y, a.y);
}
}