#include <bits/stdc++.h>
using namespace std;

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i,n) for(int64 i = 0; i < (n); i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define FORR(i,a,b) for(int64 i = (a); i >= (b);--i )
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using int64 = int_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

template<typename A, typename B> inline void chmin(A &a, B b) { if(a > b) a = b; }
template<typename A, typename B> inline void chmax(A &a, B b) { if(a < b) a = b; }

using D = double;
const D PI = acos(D(-1)), EPS = 1e-10;

int sgn(D a) { return (a < -EPS) ? -1 : (a > EPS); }
int sgn(D a, D b) { return sgn(a - b); }
struct P {
  D x, y;
  P(D _x = D(), D _y = D()) : x(_x), y(_y) {}
  P operator+(const P& r) const { return {x + r.x, y + r.y}; }
  P operator-(const P& r) const { return {x - r.x, y - r.y}; }
  P operator*(const P& r) const {
    return {x * r.x - y * r.y, x*r.y + y * r.x};
  }
  P operator*(const D& r) const { return {x * r, y * r}; }
  P operator/(const D& r) const { return {x / r, y / r}; }

  P& operator+=(const P& r) { return *this = *this + r; }
  P& operator-=(const P& r) { return *this = *this - r; }
  P& operator*=(const P& r) { return *this = *this * r; }
  P& operator*=(const D& r) { return *this = *this * r; }
  P& operator/=(const D& r) { return *this = *this / r; }

  P operator-() const { return {-x, -y}; }

  bool operator<(const P& r) const {
    return 2 * sgn(x, r.x) + sgn(y, r.y) < 0;
  }
  bool operator==(const P& r) const { return sgn((*this - r).rabs()) == 0; }
  bool operator!=(const P& r) const { return !(*this == r); }

  D norm() const { return x*x + y*y; }
  D abs() const { return sqrt(norm()); }
  D rabs() const { return max(std::abs(x), std::abs(y)); }
  D arg() const { return atan2(y, x); }

  pair<D, D> to_pair() const { return {x, y}; }
  static P polar(D le, D th) { return {le * cos(th), le * sin(th)}; }
};

ostream& operator<<(ostream& os, const P& p) {
  return os << "P{" << p.x << ", " << p.y << ")";
}

int64 n, k;

void solve() {
  D s3 = sqrt(3);
  D res = INF_LL;
  vector<P> p(n);
  REP(i, n) {
    cin >> p[i].x >> p[i].y;
  }
  vector<int64> ord(n);
  iota(all(ord), 0);
  sort(all(ord), [&](const int64& a, const int64& b) {
    return p[a].y == p[b].y ? p[a].x > p[b].x : p[a].y < p[b].y;
  });

  vector<int64> proj_l(n), proj_r(n);
  iota(all(proj_l), 0);
  iota(all(proj_r), 0);
  sort(all(proj_l), [&](int64 a, int64 b) {
    return p[a].x-p[a].y/s3 < p[b].x-p[b].y/s3;
  });
  sort(all(proj_r), [&](int64 a, int64 b) {
    return p[a].x+p[a].y/s3 < p[b].x+p[b].y/s3;
  });
  REP(i_, n) {
    int64 i = ord[i_];
    if (i_ > 0 && p[ord[i_-1]].y == p[i].y) continue;
    int64 cnt = 0, now = 0;
    REP(j, proj_l.size()) {
      int64 l = proj_l[j];
      if (p[l].y < p[i].y) continue;
      while (now < proj_l.size() && cnt < n-k) {
        int64 r = proj_r[now++];
        if (p[r].y < p[i].y) {
          continue;
        }
        D p_r = p[r].x-(p[r].y-p[i].y)/s3;
        D p_l = p[l].x-(p[l].y-p[i].y)/s3;
        if (p_r + EPS < p_l) continue;
        cnt++;
      }
      int64 r = proj_r[now-1];
      if (cnt >= n-k) {
        res = min(res, 3 * ((p[r].x+(p[r].y-p[i].y)/s3)-(p[l].x-(p[l].y-p[i].y)/s3)));
      }
      if (p[l].x+(p[l].y-p[i].y)/s3 - EPS < p[r].x + (p[r].y-p[i].y)/s3)
        cnt--;
    }
  }
  cout << fixed << setprecision(10) << res << endl;
}

int main(void){
  cin.tie(0);
  while(cin >> n && n) {
    cin >> k;
    solve();
  }
}


Measured memory_bytes: 3472