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 PYTHON):

Solution:
import collections
import copy



def f(n, k, nums):
	cc = collections.Counter(nums)
	keys = sorted(cc.keys())
	
	m = +float('inf')
	dpu = [0 for _ in range(len(keys))]
	dpo = [0 for _ in range(len(keys))]
	count = 0
	summation = 0
	for i in range(len(keys)): 
		dpu[i] = (count, summation)
		count += cc[keys[i]]
		summation += cc[keys[i]] * keys[i]
	count = 0
	summation = 0
	for i in range(len(keys)-1, -1, -1):
		dpo[i] = (count, summation)
		count += cc[keys[i]]
		summation += cc[keys[i]] * keys[i]
		
	m = float('inf')

	for i,key in enumerate(keys):
		need = max(0, k - cc[key])
		if need == 0:
			return 0

		#1
		nn = need
		cost = 0
		cost += dpu[i][0] * (key - 1) - dpu[i][1]
		nl = min(nn, dpu[i][0])
		cost += nl
		nn -= nl

		if nn:
			cost += dpo[i][1] - dpo[i][0] * ( key + 1)
			nr = min(nn, dpo[i][0])
			cost += nr
			nn -= nr
		m = min(m, cost)
		
		#2
		nn = need
		cost = 0
		cost += dpo[i][1] - dpo[i][0] * ( key + 1)
		nr = min(nn, dpo[i][0])
		cost += nr
		nn -= nr

		if nn:
			cost += dpu[i][0] * (key - 1) - dpu[i][1]
			nl = min(nn, dpu[i][0])
			cost += nl
			nn -= nl
		m = min(m, cost)
	return m



t = 1 #int(raw_input())
for i in xrange(1, t + 1):
	n, k =  [int(s) for s in raw_input().split(" ")]  # read a list of integers, 2 in this case	
	print f(n,k,map(int,raw_input().split(' ')))