/**************************************************************

     Problem: 2280

     User: rausen

     Language: C++

     Result: Accepted

     Time:90955 ms

     Memory:7068 kb

 ****************************************************************/

 #include <cstdio>

 #include <cmath>

 #include <algorithm>

 using namespace std;

 typedef double lf;

 typedef long double LF;

 const int N = 1e5 + ;

 const LF eps = 1e-;

 const LF EPS = 1e-;

 const LF inf = 1e8;

 inline int read();

 inline void print(const lf&);

 template <class T> inline T sqr(const T &x) {

     return x * x;

 }

 struct point {

     lf x, y;

     point() {}

     point(lf _x, lf _y) : x(_x), y(_y) {}

     friend inline point operator + (const point &p, const point &q) {

         return point(p.x + q.x, p.y + q.y);

     }

     friend inline point operator - (const point &p, const point &q) {

         return point(p.x - q.x, p.y - q.y);

     }

     friend inline LF operator * (const point &p, const point &q) {

         return p.x * q.y - p.y * q.x;

     }

     friend inline point operator / (const point &p, const LF &d) {

         return point(p.x / d, p.y / d);

     }

     inline void read_in() {

         x = read(), y = read();

     }

     inline void print_out() {

         print(x), putchar(' '), print(y), putchar('\n');

     }

     friend inline LF dis2(const point &p) {

         return sqr((LF) p.x) + sqr((LF) p.y);

     }

     friend inline lf dis(const point &p) {

         return sqrt(dis2(p));

     }

     friend inline point work(const point &a, const point &b, const point &c) {

         point p = b - a, q = c - a, res;

         LF d = p * q * ;

         if (fabs(d) < EPS) {

             lf ab = dis2(b - a), bc = dis2(c - b), ac = dis2(c - a);

             if (ab - bc >= EPS && ab - ac >= EPS) return (a + b) / ;

             if (bc - ab >= EPS && bc - ac >= EPS) return (b + c) / ;

             return (a + c) / ;

         }

         return point(dis2(p) * q.y - dis2(q) * p.y, dis2(q) * p.x - dis2(p) * q.x) / d + a;

 }

 } p[N], q[N], c[N], ans[N];

 int n, m, cnt;

 LF rad, now_ans;

 inline void min_cover(const int &L, const int &st, const int &R) {

     static int i, j, k;

     for (i = st; i <= R; ++i) if (dis2(q[i] - c[cnt]) > rad) {

         c[cnt] = q[i], rad = 0.0;

         for (j = L; j < i; ++j) if (dis2(q[j] - c[cnt]) > rad) {

             c[cnt] = (q[i] + q[j]) / 2.0, rad = dis2(q[i] - c[cnt]);

             for (k = L; k < j; ++k) if (dis2(q[k] - c[cnt]) > rad)

                 c[cnt] = work(q[i], q[j], q[k]), rad = dis2(q[i] - c[cnt]);

         }

     }

 }

 inline bool check(const int &l, const int &st, const int &r) {

     static int i;

     for (i = st; i <= r; ++i) q[i] = p[i];

     random_shuffle(q + st, q + r + );

     if (st == l) c[cnt] = q[l], rad = 0.0;

     min_cover(l, st, r);

     return rad < now_ans + eps;

 }

 inline bool check_ans() {

     static int l, len, del;

     cnt = l = , del = ;

     while (l + del <= n) {

         ++cnt;

         if (cnt > m) return ;

         l += del, del = ;

         for (len = ; l + len -  <= n && check(l, l + (len >> ), l + len - ); len <<= );

         del += (len >>= );

         for (; len; len >>= )

             if (l + del + len -  <= n && check(l, l, l + del + len - )) del += len;

     }

     return ;

 }

 inline void get_ans() {

     static int l, len, del;

     cnt = l = , del = ;

     while (l + del <= n) {

         ++cnt;

         l += del, del = ;

         for (len = ; l + len -  <= n && check(l, l + (len >> ), l + len - ); len <<= );

         del += (len >>= );

         for (; len; len >>= )

             if (l + del + len -  <= n && check(l, l, l + del + len - )) del += len;

         check(l, l, l + del - ), ans[cnt] = c[cnt];

     }

 }

 int main() {

     int i;

     LF ansl, ansr, mid;

     n = read(), m = read();

     for (i = ; i <= n; ++i) p[i].read_in();

     ansl = , ansr = inf;

     while (ansr - ansl > eps) {

         mid = (ansl + ansr) / 2.0;

         now_ans = sqr(mid);

         if (check_ans()) ansr = mid;

         else ansl = mid;

     }

     now_ans = sqr(ansr);

     get_ans();

     print(ansr);

     printf("\n%d\n", cnt);

     for (i = ; i <= cnt; ++i) ans[i].print_out();

     return ;

 }

 inline int read() {

     static int x, sgn;

     static char ch;

     x = , sgn = , ch = getchar();

     while (ch < '' || '' < ch) {

         if (ch == '-') sgn = -;

         ch = getchar();

     }

     while ('' <= ch && ch <= '') {

         x = x *  + ch - '';

         ch = getchar();

     }

     return sgn * x;

 }

 inline void print(const lf &x) {

     static int a, tot, pr[];

     static lf t;

     if (x < ) putchar('-'), t = -x;

     else t = x;

     a = (int) t, t -= a, tot = ;

     while (a)

         pr[++tot] = a % , a /= ;

     if (!tot) putchar('');

     while (tot) putchar(pr[tot--] + '');

     putchar('.');

     for (tot = ; tot <= ; ++tot)

         t *= , putchar((int) t %  + '');

 }