求最小值的最大值，一眼二分，可以二分一下右端点，但是考虑如果每一段长度都为
 1，那么每次都要二分 log 次，总的是 O(n^2 log n)，显然也不行。

发现复杂度瓶颈在于每次二分得到的区间长是 O(n) 级的，那么可不可以对于一个左端
点，快速的找到右端点的范围呢？我们考虑倍增，设左端点为 l，我们倍增求出右端点
的范围。设倍增得到最大的满足条件的区间长度为 2k，那么我们二分的左端点为 
i+2k−1，右端点为 min(n,i+2k+1−1)，在这段区间内二分，显然复杂度就正确了。

#include<bits/stdc++.h>
using i64 = long long;
using u64 = unsigned long long;
using ld = double;

std::mt19937_64 rng(std::chrono::steady_clock::now().time_since_epoch().count());
ld eps = 1e-13 * (rng() % 10000 + 1);

template <class T, class G>
struct BaseVector2 {
    T x, y;
    constexpr BaseVector2() : BaseVector2(T{}, T{}) {}
    constexpr BaseVector2(T x, T y) : x{x}, y{y} {}

    // 运算
    constexpr BaseVector2 operator+(BaseVector2 a) const {
        return BaseVector2(x + a.x, y + a.y);
    }
    constexpr BaseVector2 operator-(BaseVector2 a) const {
        return BaseVector2(x - a.x, y - a.y);
    }
    constexpr BaseVector2 operator-() const {
        return BaseVector2(-x, -y);
    }
    constexpr G operator*(BaseVector2 a) const {
        return G(x) * a.x + G(y) * a.y;
    }
    constexpr G operator%(BaseVector2 a) const {
        return G(x) * a.y - G(y) * a.x;
    }
    constexpr BaseVector2 rotate() const {
        return BaseVector2(-y, x);
    }
    template<class Float>
    constexpr BaseVector2 rotate(Float theta) const {
        BaseVector2 b(cosl(theta), sinl(theta));
        return BaseVector2(x * b.x - y * b.y,
                           x * b.y + y * b.x);
    }
    constexpr friend BaseVector2 operator*(const T &a, BaseVector2 b) {
        return BaseVector2(a * b.x, a * b.y);
    }

    // 比较
    constexpr bool operator<(BaseVector2 a) const {
        if (x == a.x) {
            return y < a.y;
        }
        return x < a.x;
    }

    constexpr bool operator>(BaseVector2 a) const {
        if (x == a.x) {
            return y > a.y;
        }
        return x > a.x;
    }

    constexpr bool operator<=(BaseVector2 a) const {
        if (x == a.x) {
            return y <= a.y;
        }
        return x <= a.x;
    }

    constexpr bool operator>=(BaseVector2 a) const {
        if (x == a.x) {
            return y >= a.y;
        }
        return x >= a.x;
    }

    constexpr bool operator==(BaseVector2 a) const {
        return x == a.x and y == a.y;
    }

    constexpr bool operator!=(BaseVector2 a) const {
        return x != a.x or y != a.y;
    }

    // 输入输出
    friend std::istream &operator>>(std::istream &in, BaseVector2 &p) {
        return in >> p.x >> p.y;
    }
    friend std::ostream &operator<<(std::ostream &ot, BaseVector2 p) {
        return ot << '(' << p.x << ", " << p.y << ')';
    }
};

template <class T, class G>
G dis2(BaseVector2<T, G> a, BaseVector2<T, G> b = BaseVector2<T, G>(0, 0)) {
    BaseVector2<T, G> p = a - b;
    return p * p;
}
template <class T, class G>
auto dis(BaseVector2<T, G> a, BaseVector2<T, G> b = BaseVector2<T, G>(0, 0)) {
    return sqrtl(dis2(a, b));
}

template <class T, class G>
int sgn(BaseVector2<T, G> p) {
    if (p.x < 0 or p.x == 0 and p.y > 0) {
        return 1;
    } else
        return 0;
    // 以41象限为先
}

template <class Vector>
bool polarCmp(Vector p, Vector q) {
    if (sgn(p) == sgn(q)) {
        if (p % q == 0) {
            return dis2(p) < dis2(q);
        } else {
            return p % q > 0;
        }
    } else {
        return sgn(p) < sgn(q);
    }
}

using Point = BaseVector2<ld, ld>;
using Vector = Point;
using PS = std::vector<Point>;

// Line a-b cross Line c-d (here Point = Point<ld, ld>)
Point cross(Point a, Point b, Point c, Point d) {
    Point v = c - d;
    ld sa = v % (a - d), sb = (b - d) % v;
    return 1.L * sa / (sa + sb) * (b - a) + a;
}

const ld pi = acosl(-1);
// a-b 和 a-c 的夹角 signed
ld getAngle(Point a, Point b, Point c) {
    auto v1 = b - a, v2 = c - a;
    return atan2l(v1 % v2, v1 * v2); // ∠bac
}

int sgn(const ld &a) {
    return (a < -eps ? -1 : a > eps);
}

// 对四个不同的点判断四点共圆
// d在abc外接圆外return 1, 内return -1
int inCircle(Point a, Point b, Point c, Point d) {
    ld ag1 = getAngle(a, b, c), ag2 = getAngle(d, c, b);
    if (sgn(ag1) == sgn(ag2)) {
        return sgn(pi - std::abs(ag1 + ag2));
    } else {
        return sgn(std::abs(ag1) - std::abs(ag2));
    }
}

//using pii = std::pair<int, int>;

Point excir(const Point &a, const Point &b, const Point &c) {
    // 三点求外接圆 圆心
    auto d1 = 0.5 * (a + b), d2 = d1 + (a - b).rotate();
    auto d3 = 0.5 * (c + b), d4 = d3 + (c - b).rotate();
    return cross(d1, d2, d3, d4);
}

struct MinCircleOver {
    Point Center;
    ld Radius = 0;//?

    MinCircleOver(PS ps) {
        std::shuffle(begin(ps), end(ps), std::mt19937(time(0)));

        for (int i = 0; i < ps.size(); i++) {
            if (sgn(dis(Center, ps[i]) - Radius - eps) <= 0) 
                continue;
                
            // i点不在圆内,说明 i要更新圆
            Center = ps[i], Radius = 0;
            for (int j = 0; j < i; j++) {
                if (sgn(dis(Center, ps[j]) - Radius - eps) <= 0)
                    continue;
                // j不在圆内,说明 j要更新圆
                Center = 0.5 * (ps[i] + ps[j]), Radius = dis(Center, ps[i]);
                for (int k = 0; k < j; k++) {
                    if (sgn(dis(Center, ps[k]) - Radius - eps) <= 0)
                        continue;
                    // k不在圆内,说明 k要更新圆
                    Center = excir(ps[i], ps[j], ps[k]), Radius = dis(Center, ps[i]);
                }
            }
        }
    }
};

PS ps(100000), rps(100000);
Point Center;
ld Radius;
void FastMCO(int l, int r) {//卡常技巧：手动随机化
    int cnt = 0;
    for (int i = l; i <= r; i++) rps[cnt++] = ps[i];
    for (int i = 0; i < cnt; i++) std::swap(rps[i], rps[rng() % cnt]);

    Center = rps[0];
    Radius = 0;
    for (int i = 0; i < cnt; i++) {
        if (sgn(dis(Center, rps[i]) - Radius - eps) <= 0) 
            continue;
            
        // i点不在圆内,说明 i要更新圆
        Center = rps[i], Radius = 0;
        for (int j = 0; j < i; j++) {
            if (sgn(dis(Center, rps[j]) - Radius - eps) <= 0)
                continue;
            // j不在圆内,说明 j要更新圆
            Center = 0.5 * (rps[i] + rps[j]), Radius = dis(Center, rps[i]);
            for (int k = 0; k < j; k++) {
                if (sgn(dis(Center, rps[k]) - Radius - eps) <= 0)
                    continue;
                // k不在圆内,说明 k要更新圆
                Center = excir(rps[i], rps[j], rps[k]), Radius = dis(Center, rps[i]);
            }
        }
    }
}

void solve() {
    int n, m;
    std::cin >> n >> m;
    
    // PS ps(n);
    // for (auto &[x, y] : ps) {
    //     std::cin >> x >> y;
    // }
    for (int i = 0; i < n; i++) {
        std::cin >> ps[i];
    }

    std::vector<std::array<int, 2>> res(m);

    int m_ = 0;
    auto ck = [&](ld R) {
        m_ = 0;
        int ans = 0;
        for (int i = 0; i < n; i = ans + 1) {
            int k;
            for (k = 1; i + (1 << k) < n; k++) {    //倍增压缩范围
                //PS ps_(ps.begin() + i, ps.begin() + i + (1 << k) + 1);
                //MinCircleOver get(ps_);
                FastMCO(i, i + (1 << k));
                if (Radius > R + eps) break;
            }

            ans = i;
            int l = i + (1 << (k - 1)), r = std::min(n - 1, i + (1 << k));
            while (l <= r) {    //二分
                int mid = (l + r) / 2;
                //PS ps_(ps.begin() + i, ps.begin() + mid + 1);
                //MinCircleOver get(ps_);
                FastMCO(i, mid);
                
                if (Radius < R + eps) {
                    l = mid + 1;
                    ans = mid;
                } else {
                    r = mid - 1;
                }
            }

            res[m_][0] = i;
            res[m_++][1] = ans;
            if (m_ > m) return 0;
        }
        return 1;
    };

    //MinCircleOver init(ps);
    FastMCO(0, n - 1);
    ld l = 0, r = Radius;
    if (m > 1) {
        int cnt = 50;//二分上限50次
        
        while (cnt-- && r - l > eps) {
            ld mid = (l + r) / 2;
            if (ck(mid)) r = mid;
            else l = mid;
        }

        ck(r);
        std::cout << r << "\n";
        std::cout << m_ << "\n";
        for (int i = 0; i < m_; i++) {
            //PS ps_(ps.begin() + res[i][0], ps.begin() + res[i][1] + 1);
            //MinCircleOver mco(ps_);
            FastMCO(res[i][0], res[i][1]);
            std::cout << Center.x << " " << Center.y << "\n";
        }
    } else {
        std::cout << Radius << "\n";
        std::cout << "1\n";
        std::cout << Center.x << " " << Center.y;
    }
}

signed main(){
    std::cin.tie(0) -> sync_with_stdio(false);
    int t = 1;
    //std::cin >> t;
    std::cout << std::setprecision(8) << std::fixed;
    while(t--) solve();
    return 0;
}