#include <bits/stdc++.h>

using ld = long double;
using coors = std::pair<ld, ld>;
const ld pi = 3.14159265358979323846264338327950288419716939937510L;
const ld coef = std::tan(pi * 2 / 3);

// y = ax + b
// b = y - ax
std::stack<std::pair<int, ld>> sort_coors(const std::vector<coors> &cv, ld a) {
    std::vector<std::pair<int, ld>> v(cv.size());
    for (int i = 0; i < cv.size(); i++) {
        ld x, y;
        std::tie(x, y) = cv[i];
        v[i] = std::make_pair(i, y - a * x);
    }
    std::sort(v.begin(), v.end(), 
              [](const auto &p, const auto &q) { return p.second < q.second; });
    std::stack<std::pair<int, ld>> que;
    for (auto e : v) que.push(e);
    return que;
}

template <typename T>
void chmin(T &a, T b) {
    a = std::min(a, b);
}

template <typename T>
void chmax(T &a, T b) {
    a = std::max(a, b);
}

std::array<bool, 10'000> ok_c, ok, use;

ld solve(std::vector<coors> &cv, int k) {
    int n = cv.size();
    std::sort(cv.begin(), cv.end(), 
              [](const auto &p, const auto &q) { return p.second > q.second; });
    int bound = n - k;
    auto sa = sort_coors(cv, coef);
    std::fill(ok_c.begin(), ok_c.begin() + n, true);
    ld ans = 1e18;
    auto sb_o = sort_coors(cv, -coef);
    auto sc_o = sort_coors(cv, 0);

    while (bound <= sa.size()) {
        auto sb = sb_o;
        auto sc = sc_o;
        int cnt = 0;
        std::copy(ok_c.begin(), ok_c.begin() + n, ok.begin());
        std::fill(use.begin(), use.begin() + n, false);
        ld miny = 1e18;

        for (int i = 0; i < n && cnt < bound; i++) {
            if (!ok[i]) continue;
            use[i] = true;
            chmin(miny, cv[i].second);
            cnt++;
        }

        while (bound <= sb.size()) {
            while (cnt < bound && sc.size()) {
                int idx;
                ld b;
                std::tie(idx, b) = sc.top();
                sc.pop();
                if (!ok[idx]) continue;
                if (use[idx]) continue;
                use[idx] = true;
                cnt++;
                chmin(miny, b);
            }
            if (cnt < bound) break;
            // y = ax + b
            // ax = y - b
            // x = (y - b) / a
            ld b1 = sa.top().second;
            ld b2 = sb.top().second;
            ld x1 = (miny - b1) / coef;
            ld x2 = (miny - b2) / -coef;
            ld dist = std::abs(x1 - x2);
            chmin(ans, dist * 3);
            while (sb.size() && bound <= sb.size()) {
                int idx;
                std::tie(idx, std::ignore) = sb.top();
                sb.pop();
                ok[idx] = false;
                if (use[idx]) {
                    use[idx] = false;
                    cnt--;
                }
                break;
            }
        }
        int idx;
        std::tie(idx, std::ignore) = sa.top();
        sa.pop();
        ok_c[idx] = false;
    }

    return ans;
}

bool solve() {
    int n, k;
    std::cin >> n;
    if (n == 0) return false;
    std::cin >> k;
    std::vector<coors> cv(n);
    for (auto &&e : cv) {  
        ld a, b;
        std::cin >> a >> b;
        e = coors(a, b);
    }
    std::cout << solve(cv, k) << "\n";
    return true;
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(30);
    while (solve());
    return 0;
}



Measured memory_bytes: 5176