Problem: Equilateral Triangular Fence

Ms. Misumi owns an orchard along a straight road. Recently, wild boars have been witnessed strolling around the orchard aiming at pears, and she plans to construct a fence around many of the pear trees.

The orchard contains n pear trees, whose locations are given by the two-dimensional Euclidean coordinates (x1, y1),..., (xn, yn). For simplicity, we neglect the thickness of pear trees. Ms. Misumi's aesthetic tells that the fence has to form a equilateral triangle with one of its edges parallel to the road. Its opposite apex, of course, should be apart from the road. The coordinate system for the positions of the pear trees is chosen so that the road is expressed as y = 0, and the pear trees are located at y ≥ 1.

Due to budget constraints, Ms. Misumi decided to allow at most k trees to be left outside of the fence. You are to find the shortest possible perimeter of the fence on this condition.

The following figure shows the first dataset of the Sample Input. There are four pear trees at (−1,2), (0,1), (1,2), and (2,1). By excluding (−1,2) from the fence, we obtain the equilateral triangle with perimeter 6.

<image>

Input

The input consists of multiple datasets, each in the following format.

> n
>  k
>  x1 y1
>  ...
>  xn yn
>

Each of the datasets consists of n+2 lines. n in the first line is the integer representing the number of pear trees; it satisfies 3 ≤ n ≤ 10 000. k in the second line is the integer representing the number of pear trees that may be left outside of the fence; it satisfies 1 ≤ k ≤ min(n−2, 5 000). The following n lines have two integers each representing the x- and y- coordinates, in this order, of the locations of pear trees; it satisfies −10 000 ≤ xi ≤ 10 000, 1 ≤ yi ≤ 10 000. No two pear trees are at the same location, i.e., (xi, yi)=(xj, yj) only if i=j.

The end of the input is indicated by a line containing a zero. The number of datasets is at most 100.

Output

For each dataset, output a single number that represents the shortest possible perimeter of the fence. The output must not contain an error greater than 10−6.

Sample Input


4
1
0 1
1 2
-1 2
2 1
4
1
1 1
2 2
1 3
1 4
4
1
1 1
2 2
3 1
4 1
4
1
1 2
2 1
3 2
4 2
5
2
0 1
0 2
0 3
0 4
0 5
6
3
0 2
2 2
1 1
0 3
2 3
1 4
0


Output for the Sample Input


6.000000000000
6.928203230276
6.000000000000
7.732050807569
6.928203230276
6.000000000000






Example

Input

4
1
0 1
1 2
-1 2
2 1
4
1
1 1
2 2
1 3
1 4
4
1
1 1
2 2
3 1
4 1
4
1
1 2
2 1
3 2
4 2
5
2
0 1
0 2
0 3
0 4
0 5
6
3
0 2
2 2
1 1
0 3
2 3
1 4
0


Output

6.000000000000
6.928203230276
6.000000000000
7.732050807569
6.928203230276
6.000000000000

Solution (in CPP):

Solution:
#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();
  }
}