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

Solution:
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
struct fast_ios {
  fast_ios() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
  };
} fast_ios_;
template <typename T>
bool chmin(T &m, const T q) {
  if (m > q) {
    m = q;
    return true;
  } else
    return false;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
  for (auto &v : vec) is >> v;
  return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
  os << "[";
  for (auto v : vec) os << v << ",";
  os << "]";
  return os;
}
lint sol2(vector<lint> A, lint K, lint t) {
  for (auto x : A)
    if (x == t) K--;
  if (K <= 0) return 0;
  int nb = 0;
  lint cost = 0;
  for (auto x : A)
    if (x < t) cost += t - x, nb++;
  if (nb < K)
    return 1e18;
  else
    return cost - (nb - K);
}
lint solve(vector<lint> A, lint K) {
  map<lint, int> cnt;
  for (auto x : A) cnt[x]++;
  for (auto p : cnt)
    if (p.second >= K) return 0;
  lint tmp = sol2(A, K, A[K - 1]);
  if (K < A.size()) chmin(tmp, sol2(A, K, A[K]));
  lint med = A[A.size() / 2];
  int notsame = 0;
  lint c2 = 0;
  for (auto x : A) {
    c2 += abs(med - x);
    if (x != med) notsame++;
  }
  c2 -= min<int>(notsame, A.size() - K);
  chmin(tmp, c2);
  return tmp;
}
int main() {
  int N, K;
  cin >> N >> K;
  vector<lint> A(N);
  cin >> A;
  sort(A.begin(), A.end());
  lint ret1 = solve(A, K);
  for (auto &a : A) a = 1010101010 - a;
  sort(A.begin(), A.end());
  lint ret2 = solve(A, K);
  cout << min(ret1, ret2) << endl;
}