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:
    //  package com.company;
        import java.io.BufferedReader;
        import java.io.IOException;
        import java.util.*;import java.io.InputStreamReader;

        public class Main{
            static class FastReader
            {
                BufferedReader br;
                StringTokenizer st;

                public FastReader()
                {
                    br = new BufferedReader(new
                            InputStreamReader(System.in));
                }

                String next()
                {
                    while (st == null || !st.hasMoreElements())
                    {
                        try
                        {
                            st = new StringTokenizer(br.readLine());
                        }
                        catch (IOException  e)
                        {
                            e.printStackTrace();
                        }
                    }
                    return st.nextToken();
                }

                int nextInt()
                {
                    return Integer.parseInt(next());
                }

                long nextLong()
                {
                    return Long.parseLong(next());
                }

              double  doublenextDouble()
                {
                    return Double.parseDouble(next());
                }

                String nextLine()
                {
                    String str = "";
                    try
                    {
                        str = br.readLine();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    return str;
                }
            }
            static int n;static long x=0;static int m;
            private static int max=Integer.MIN_VALUE;static long ans=Long.MIN_VALUE;
            private static  LinkedList<Integer> adj[];private static LinkedList<Integer> g1=new LinkedList<Integer>();private static LinkedList<Integer> l=new LinkedList<Integer>();
            public static void main(String[] args){
                FastReader s=new FastReader();StringBuilder sb=new StringBuilder();
    //    int n=s.nextInt();//Queue<Integer>[] q=new LinkedList[1000000];
      //int n=s.nextInt();//char[]a=s.next().toCharArray();char[] b=s.next().toCharArray();
//      Stack<Integer> qa=new Stack<Integer>();Stack<Integer> qb=ne&&w Stack<Integer>();
           long n=s.nextLong();
           long k=s.nextLong();
           long [] a=new long[(int)n];
                HashMap<Long,Long> count=new HashMap<Long, Long>();
                HashMap<Long,Long> c=new HashMap<Long, Long>();
                long min=Long.MAX_VALUE;

                for(int i=0;i<n;i++){
               a[i]=s.nextLong();}
               Arrays.sort(a);
               for(int i=0;i<n;i++){
               for(int j=0;j<=18;j++){
                 if(count.containsKey(a[i]/(long)Math.pow(2,j))){
                     if(count.get(a[i]/(long)Math.pow(2,j))+1==k){
                         if(c.get(a[i]/(long)Math.pow(2,j))+j<min){
                             min=c.get(a[i]/(long)Math.pow(2,j))+j;
                         }
                     }count.put(a[i]/(long)Math.pow(2,j),count.get(a[i]/(long)Math.pow(2,j))+1);c.put(a[i]/(long)Math.pow(2,j),c.get(a[i]/(long)Math.pow(2,j))+j);
                 }else{
                             if(1==k){
                                 if(j<min){
                                     min=j;
                                 }
                             }count.put(a[i]/(long)Math.pow(2,j),1L);c.put(a[i]/(long)Math.pow(2,j),(long)j);
                         }
                   if(a[i]/(long)Math.pow(2,j)==0) break;
               }
           }
                System.out.println(min);


                }}