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
import java.util.*;
import java.io.*;
 
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Task solver = new Task();
 
		int i = 0;
		int t = 1;
		//t = in.nextInt();
		for (; i < t; i++)
			solver.solve(i, in, out);
 
		out.close();
	}
 
	static class Task {
		public void solve(int testNumber, InputReader in, PrintWriter out) {
				int n = in.nextInt();
				int k = in.nextInt();
				int[][] ar = new int[200001][2];
				for(int i = 0; i < n; i++) {
					ar[in.nextInt()][0]++;
				}
				for(int i = 2; i < 200001; i++) {
					int c = i;
					int counter = 0;
					while(c > 0) {
						counter++;
						c /= 2;
						if(ar[c][0] < k) {
							if(ar[i][0] + ar[c][0] <= k) {
								ar[c][0] += ar[i][0];
								ar[c][1] += ar[i][0] * counter;
							}else {
								ar[c][1] += counter * (k - ar[c][0]);
								ar[c][0] = k;
							}
						}
					}
				}
				int min = Integer.MAX_VALUE;
				for(int i = 1 ; i < ar.length; i++) {
					if(ar[i][0] >= k) {
						min = min > ar[i][1] ? ar[i][1] : min;
					}
				}
				
				out.print(min);
				
				
				
 
		}
 
	}
 
	// template code
 
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
 
		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}
 
		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}
 
		public int nextInt() {
			return Integer.parseInt(next());
		}
 
		public long nextLong() {
			return Long.parseLong(next());
		}
 
		public double nextDouble() {
			return Double.parseDouble(next());
		}
 
	}
 
	static long modexp(long a, long b, long p) {
		// returns a to the power b mod p by modular exponentiation
 
		long res = 1;
		long mult = a % p;
		while (b > 0) {
			if (b % 2 == 1) {
				res = (res * mult) % p;
			}
			b /= 2;
			mult = (mult * mult) % p;
		}
 
		return res;
	}
 
	static double log(double arg, double base) {
		// returns log of a base b, contains floating point errors, dont use for exact
		// calculations.
 
		if (base < 0 || base == 1) {
			throw new ArithmeticException("base cant be 1 or negative");
		}
		if (arg < 0) {
			throw new ArithmeticException("log of negative number undefined");
		}
		return Math.log10(arg) / Math.log10(base);
	}
 
	static long gcd(long a, long b) {
		if (a == 0) {
			return b;
		} else {
			return gcd(b % a, a);
		}
	}
	
	static int gcd(int a, int b) {
		if (a == 0) {
			return b;
		} else {
			return gcd(b % a, a);
		}
	}
	
	
}