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.*;
import java.math.BigInteger;

public class notYet {
	
	
	public static void main(String[] args)throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter out = new PrintWriter(System.out);
		
		StringTokenizer st1 = new StringTokenizer(br.readLine());
		
		int n = Integer.parseInt(st1.nextToken());
		int k = Integer.parseInt(st1.nextToken());
		
		Integer arr[] = new Integer[n];
		
		st1 = new StringTokenizer(br.readLine());
		
		int cnt[] = new int[200000 + 1];
		boolean flag = false;
		HashMap<Integer, Integer> hm = new HashMap<>();
		
		for(int i = 0 ; i < n ; i++)
		{
			arr[i] = Integer.parseInt(st1.nextToken());
			cnt[arr[i]]++;
			
			hm.put(arr[i], 0);
			
			if(cnt[arr[i]] >= k)
			{
				flag = true;
			}
		}
		
		Arrays.sort(arr);
		if(flag)
			out.println(0);
		else
		{
			int min = Integer.MAX_VALUE;
			for(int i = 0 ; i < n ; i++)
			{
				
					
				
				int gCnt = 0;
				int x = arr[i];
				while(x > 0)
				{
					x = x / 2;
					gCnt++;
					cnt[x]++;
					hm.put(x, hm.getOrDefault(x, 0) + gCnt);
					if(cnt[x] >= k)
					{
						min = Math.min(min, hm.get(x));
					}
					
				}
				
			
			}
			
			out.println(min);
		}
			
		
		
		
		out.flush();
		out.close();
	}
	
	
	


}