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

constexpr int mod = 1e9 + 7;

#define dump(x) ([&](){auto ___val = (x); cout << #x << " = " << (___val) << endl; })();
// #define dump(x) ;


template<class T>
ostream&operator<<(ostream &os, vector<T>v) {
  os << "{";
  for(size_t i = 0; i < v.size(); i++) os << v[i] << ", ";
  os << "}";
  return os;
}

template<class T, class U>
ostream&operator<<(ostream &os, pair<T, U>v) {
  os << "(" << v.first << " , " << v.second << ")";
  return os;
}

template<class T, class U>
ostream&operator<<(ostream &os, map<T, U>v) {
  os << "(map: \n";
  for(auto e : v) os << e << ", \n";
  os << ")";
  return os;
}

template<class T>
ostream&operator<<(ostream &os, set<T>v) {
  os << "(set: \n";
  for(auto e : v) os << e << ", \n";
  os << ")";
  return os;
}

using Vec = vector<int>;
using Mat = vector<Vec>;

ll modpow(ll x, ll k, ll mod) {
  x %= mod;
  ll r = 1;
  assert(k >= 0);
  while(k) {
    if(k & 1) r = r * x % mod;
    x = x * x % mod;
    k >>= 1;
  }
  return r;
}

ll toint(string s) {
  ll res = 0;
  int n = s.size();
  for(int i = 0; i < n; i++) res |= (ll(s[n - 1 - i] - '0')) << i;
  return res;
}

string tostr(ll x, int n) {
  string res = "";
  for(int i = 0; i < n; i++) {
    res += '0' + ((x >> i) & 1);
  }
  reverse(begin(res), end(res));
  return res;
}

bool mul_OF(ll a, ll b) {
  // a * b > 4e18
  // a > floor(4e18 / b)
  return a > ll(1e18) / b;
}


// O(k^2) が間に合うのか…

int main() {
  ios::sync_with_stdio(0), cin.tie(0);

  const double r3 = sqrt(3);

  while(1) {
    int n, k;
    cin >> n;
    if(!n) break;
    cin >> k;
    vector<double> x(n), y(n);
    for(int i = 0; i < n; i++) cin >> x[i] >> y[i];
    vector<double> kL(n), kR(n);
    for(int i = 0; i < n; i++) kL[i] = -(y[i] - r3 * x[i]), kR[i] = y[i] + r3 * x[i];
    vector<int> yord(n);
    iota(begin(yord), end(yord), 0);
    sort(begin(yord), end(yord), [&](int i, int j) {
        return y[i] < y[j];
        });

    using P = pair<double, int>;
    set<P> kLord, kRord;

    for(int i = 0; i < n; i++) kLord.emplace(kL[i], i);
    for(int i = 0; i < n; i++) kRord.emplace(kR[i], i);

    vector<int> kL_rank(n);
    vector<int> kR_rank(n);

    {
      auto ite = kLord.begin();
      for(int i = 0; i < n; i++, ite++) kL_rank[ite->second] = i;
    }
    {
      auto ite = kRord.begin();
      for(int i = 0; i < n; i++, ite++) kR_rank[ite->second] = i;
    }

    // yの昇順に, 捨てていって,
    // 右側を最大捨てて,
    // 右を左に動かしていく

    // dump(kLord);
    // dump(kRord);

    double ans = 1e18;

    for(int i = 0; i <= k; i++) {
      assert(n - i == kLord.size());
      assert(n - i == kRord.size());

      int drop = 0;
      int yid = yord[i];
      int ab = k - i;
      double ycord = y[yid];
      // 捨てる
      auto iteR = kRord.end();
      auto iteL = kLord.begin();
      for(int rem = 0; rem < ab && iteR != kRord.begin(); rem++, iteR--) ;
      assert(iteR != kRord.begin());
      while(1) {
        int lid = iteL->second;
        int rid = prev(iteR)->second;
        // dump(x[lid]); dump(y[lid]);
        while(kR_rank[lid] > kR_rank[rid] || drop) {
          // dump(drop);
          if(kR_rank[lid] > kR_rank[rid]); else drop--;
          iteL++;
          assert(iteL != kLord.end());
          lid = iteL->second;

        }
        double L = 
          - 1.0 / r3 * (ycord - kR[rid])
          - 1.0 / r3 * (ycord + kL[lid]);
        ans = min(ans, L);

        // dump(ycord);
        // dump(x[rid]); dump(y[rid]);
        // dump(x[lid]); dump(y[lid]);
        // dump(L);
        // dump("");

        if(iteR == kRord.end()) break;
        iteR++;
        rid = prev(iteR)->second;
        if(kL_rank[lid] < kL_rank[rid]) drop++;
      }


      // y 座標的に捨てる
      kLord.erase(make_pair(kL[yid], yid));
      kRord.erase(make_pair(kR[yid], yid));
    }

    cout << fixed << setprecision(20) << ans * 3 << "\n";
  }
}




