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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool good(pnt a, pnt b, pnt c) {
    if ((b - a & c - a) < 0) return 0;
    if ((c - b & a - b) < 0) return 0;
    if ((a - c & b - c) < 0) return 0;
    return 1;
}

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
//    for (int j = 0; j < n * k && vec.size() < 12; j ++) if (!vis[j]) vec.push_back(j);
//    int sz = vec.size();
//    for (int a = 0; a < sz; a ++) {
//        for (int b = 0; b < a; b ++) {
//            for (int c = 0; c < b; c ++) {
//                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
//                for (int x = -0; x <= 0; x ++) {
//                    for (int y = -0; y <= 0; y ++) {
//                        pnt P = O; P.x += x, P.y += y;
//                        double r = dist(P - p[vec[a]]);
//                        vector <int> vec;
//                        if (check(P, r, vec)) {
//                            ans[cc] = P, ans_r[cc] = r;
//                            if (solve(cc + 1)) return 1;
//                            int sz = vec.size();
//                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
//                        }
//                    }
//                }
//            }
//        }
//    }
    for (int j = 0; j < n * k; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size(), cnt = 0;
    while (cnt < 100) {
        int a = rand() % sz, b = rand() % sz, c = rand() % sz;
        while (b == a) b = rand() % sz;
        while (c == b || c == a) c = rand() % sz;
        pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
        double r = dist(O - p[vec[a]]);
        vector <int> vec;
        if (check(O, r, vec)) {
            ans[cc] = O, ans_r[cc] = r;
            if (solve(cc + 1)) return 1;
            int sz = vec.size();
            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
        }
        cnt ++;
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.03);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n, tmp[200000], cnt = 0;

double X[4010], Y[4010], avg1[10010], avg2[10010], Ansx[200000], Ansy[1200000], qwq[200000];

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

vector <double> V;

void Do(double x, double y, double o) {
    V.clear();
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), o));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
}

double getval(double x, double y) {
    Do(x, y, 2);
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n);
	return magic;
}

double getr(double x, double y) {
	Do(x, y, 1);
	double magic = 1e100;
	int v, n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

bool cmp(int x, int y) {return qwq[x] < qwq[y];}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) scanf("%lf%lf", &X[i], &Y[i]);
	for(int i = -50; i <= 50; i++)
		for(int j = -50; j <= 50; j++) if(dis(0, 0, i * 20000, j * 20000) <= 1e6)
			Ansx[++cnt] = i * 20000, Ansy[cnt] = j * 20000, qwq[cnt] = getval(i * 20000, j * 20000);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 4e5) qwq[i] = 1e100;
	}
	return 0;
}

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

struct point {
  double x, y;
  point() {}
  point(double x_, double y_) : x(x_),y(y_) {}
  double len() {
    return sqrt(x*x+y*y);
  }
};
point operator-(const point& a, const point& b) {
  return {a.x-b.x, a.y-b.y};
}
point operator+(const point& a, const point& b) {
  return {a.x+b.x, a.y+b.y};
}
double operator*(const point& a, const point& b) {
  return a.x*b.x+a.y*b.y;
}
double operator%(const point& a, const point& b) {
  return a.x*b.y-a.y*b.x;
}
point operator*(const point& a, double f) {
  return {a.x*f, a.y*f};
}

struct Circle {
  point p;
  double r;
};

mt19937_64 mrand(chrono::steady_clock::now().time_since_epoch().count());
#define random erghergh
double random() {
  return 1.*mrand()/mrand.max();
}

point sampleCenter() {
  double x, y;
  do {
    x = random()*2e6-1e6;
    y = random()*2e6-1e6;
  } while (x*x+y*y > 1e6*1e6);
  return {x,y};
}

double pi = 3.141592653589793;

double circleDist(Circle a, Circle b) {
  double d = (a.p-b.p).len();
  double r1 = a.r, r2 = b.r;
  double dpp = abs(d+r1+r2);
  double dpm = abs(d+r1-r2);
  double dmp = abs(d-r1+r2);
  double dmm = abs(d-r1-r2);
  double haus = max({
      min(dmm,dmp),
	min(dpm,dpp),
	min(dmm,dpm),
	min(dmp,dpp)});
  return haus;
}

vector<point> genPoints(int n, int k, vector<Circle>&ans, int read = 0) {
  ans.resize(k);
  if (read) {
    for (int i = 0; i < k; i++) {
      cin >> ans[i].p.x >> ans[i].p.y >> ans[i].r;
    }
  } else {
    int ok = 0;
    while (!ok) {
      ok = 1;
      for (int i = 0; i < k; i++) {
	ans[i].p = sampleCenter();
	ans[i].r = random()*5e5+2.5e5;
	for (int j = 0; j < i; j++) {
	  if (circleDist(ans[i],ans[j]) < 6e5) ok = 0;
	}
      }
    }
  }
  vector<point> points;
  for (int i = 0; i < k; i++) {
    for (int j = 0; j < n; j++) {
      double theta = random()*pi*2;
      double r = (random()*0.2+0.9)*ans[i].r;
      points.push_back({cos(theta)*r+ans[i].p.x, sin(theta)*r+ans[i].p.y});
    }
  }
  //shuffle(points.begin(), points.end(), mrand());
  return points;
}

Circle findCircle(point a, point b, point c) {
  Circle r;
  r.p = (point(a.y-b.y,b.x-a.x)*((a-c)*(b-c)/((a-b)%(b-c)))+a+b)*0.5;
  r.r = (a-r.p).len();
  //cout << (a-r.p).len() << ' ' << (b-r.p).len() << ' ' << (c-r.p).len() << endl;
  return r;
}

Circle refineCircle1(Circle old, vector<point>&points, int plot = 0) {
  int n = points.size();
  vector<double> x, y, r;
  x.push_back(old.p.x);
  y.push_back(old.p.y);
  r.push_back(old.r);
  for (int it = 0; it < 100; it++) {
    int ai = mrand()%n;
    int bi = mrand()%n;
    int ci = mrand()%n;
    Circle c = findCircle(points[ai], points[bi], points[ci]);
    if (c.r > old.r*0.9 && c.r < old.r*1.1) {
      x.push_back(c.p.x);
      y.push_back(c.p.y);
      r.push_back(c.r);
    }
  }
  if (plot) {
    for (int i = 0; i < x.size(); i++) {
      cerr << x[i] << ' ' << y[i] << endl;
    }
  }
  sort(x.begin(), x.end());
  sort(y.begin(), y.end());
  sort(r.begin(), r.end());
  int k = x.size()/2;
  return {{x[k], y[k]}, r[k]};
}

Circle refineCircle(Circle old, vector<point>&points, int plot = 0) {
  int n = points.size();
  const int sections = 8;

  for (int it = 0; it < 100; it++) {
    vector<double> r;
    r.push_back(old.r);
    for (point p : points) {
      double rr = (p-old.p).len();
      if (rr > old.r*0.8 && rr < old.r*1.2)
	r.push_back(rr);
    }
    sort(r.begin(), r.end());
    old.r = r[r.size()/2];

    if (plot) {
      cerr << old.p.x << ' ' << old.p.y << endl;
    }

    vector<int> section(sections, 0);
    vector<point> pos(sections, {0,0});
    for (point p : points) {
      int i = sections*(atan2(p.y-old.p.y,p.x-old.p.x)+pi)/(2*pi);
      assert(i >= 0 && i < sections);
      point f = p-old.p;
      double r = f.len();
      if (r > old.r*0.8 && r < old.r*1.2) {
	f = f*((r > old.r ? 1. : -1)/r);
	pos[i] = (pos[i]*section[i]+f)*(1./(section[i]+1));
	section[i]++;
      }
    }
    point dp(0,0);
    for (int i = 0; i < sections; i++) {
      dp = dp+pos[i]*1e4;
      continue;
      double a = (i+0.5)/sections*2*pi-pi;
      point p = point(cos(a),sin(a))*old.r+old.p;
      //cout << sections*(atan2(p.y-old.p.y,p.x-old.p.x)+pi)/(2*pi)-i-0.5 << endl;
      if (section[i] == 0) {
	section[i]++;
	pos[i] = pos[i]+p;
      }
      /*if (plot) {
	cerr << p.x << ' ' << p.y << endl;
	}*/
    }
    if (dp.len() < 1e3) break;
    old.p = old.p+dp;
  }
  return old;
}

double scoreCircle2(Circle c, vector<point>&points, double tol) {
  int count = 0;
  vector<double> ang;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      count++;
      ang.push_back(atan2(d.y,d.x));
    }
  }
  ang.push_back(-pi);
  ang.push_back(pi);
  sort(ang.begin(), ang.end());
  double last = ang[0];
  double maxgap = 0;
  for (double d : ang) {
    maxgap = max(maxgap, d-last);
    last = d;
  }
  return maxgap;
}

int found[22][12];
int nx = 20, ny;

double scoreCircle(Circle c, vector<point>&points, double tol, int plot = 0) {
  for (int i = 0; i < nx; i++)
    for (int j = 0; j < ny; j++)
      found[i][j] = 0;

  int score = 0;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    int x = nx*(atan2(d.y,d.x)+pi)/(2*pi);
    assert(x >= 0 && x < nx);
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      int y = (r-(1-tol))/(tol*2)*ny;
      assert(y >= 0 && y < ny);
      score += !(found[x][y]++);
    }
  }
  if (plot) {
    for (int x = 0; x < nx; x++) {
      for (int y = 0; y < ny; y++) {
	if (found[x][y]) {
	  double a = (x+0.5)/nx*2*pi-pi;
	  double r = c.r*((y+0.5)/ny*(2*tol)+(1-tol));
	  point p = point(cos(a),sin(a))*r+c.p;
	  cerr << p.x << ' ' << p.y << endl;
	}
      }
    }
  }
  return -score;
}

vector<point> filterCircle(Circle c, vector<point>&points, double tol) {
  vector<point> goods;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      goods.push_back(points[i]);
    }
  }
  return goods;
}

int main() {
  ios::sync_with_stdio(0); cin.tie(0);
  for (int trials = 0; trials < 10000*0+1; trials++) {
    //cout << trials << endl;
    int n = mrand()%901+100, k = mrand()%4+1;
    cin >> k >> n;

    nx = 20;
    ny = 3;
    vector<Circle> truth;
    vector<point> points(n*k);// = genPoints(n, k, truth);
    for (int i = 0; i < n*k; i++) {
      cin >> points[i].x >> points[i].y;
    }
    vector<pair<double,Circle>> cands;
    for (int it = 0; it < 100000; it++) {
      int ai = mrand()%(n*k);
      int bi = mrand()%(n*k);
      int ci = mrand()%(n*k);
      if (set<int>({ai,bi,ci}).size() < 3) continue;
      Circle c = findCircle(points[ai], points[bi], points[ci]);
      if (c.r > 7.5e5 || c.r < 2.5e5) continue;

      //vector<point> goods = filterCircle(p, a);
      //c = refineCircle(c, goods);
      //auto pb = scoreCircle(c, points, 0.1);
      double maxgap = scoreCircle(c, points, 0.1);
      //if (pb.second.size() >= n*0.9)
      cands.push_back({-maxgap,c});
      //cerr << c.p.x << ' ' << c.p.y << endl;
    }
    sort(cands.begin(), cands.end(), [](pair<double,Circle> a, pair<double,Circle> b) {return a.first > b.first;});
    vector<Circle> ans;
    for (auto pa : cands) {
      Circle a = pa.second;
      int ok = 1;
      for (Circle b : ans) {
	if (circleDist(a,b) < 5.5e5) ok = 0;
      }
      if (ok == 1) {
	ans.push_back(a);
	if ((int)ans.size() == k) break;
      }
    }
    if ((int)ans.size() < k) {
      cout << "Only found " << ans.size() << " circles" << endl;
      return 0;
    }

    vector<Circle> backup = ans;
    for (Circle&c : ans) {
      auto goods = filterCircle(c, points, 0.2);
      c = refineCircle(c, goods);
    }

    cout << setprecision(20);
    for (Circle c : ans) {
      cout << c.p.x << ' ' << c.p.y << ' ' << c.r << endl;
    }

    if (0) {
      int ok = 0;
      for (int i = 0; i < k; i++) {
	double min_dist = 1e9;
	double mini = -1;
	for (int j = 0; j < k; j++) {
	  double haus = circleDist(truth[i], ans[j]);
	  if (haus < min_dist) {
	    min_dist = haus;
	    mini = j;
	  }
	}
	if (min_dist > 1e5) {
	  cout << min_dist/1e5 << endl;
	  cout << scoreCircle(truth[i], points, 0.1) << ' ' << scoreCircle(backup[mini], points, 0.1) << ' ' << scoreCircle(ans[mini], points, 0.1) << endl;
	} else ok++;
      }
      if (ok != k) {
	cout << "Failed" << endl;
	for (point p : points) {
	  cerr << p.x << ' ' << p.y << endl;
	}
	cerr << endl << endl;
	for (Circle c : ans) {
	  cout << "Score: " << scoreCircle(c, points, 0.1, 1) << endl;
	  auto goods = filterCircle(c, points, 0.2);
	  refineCircle(c, goods, 1);
	  cerr << c.p.x << ' ' << c.p.y << ' ' << endl;
	  for (int i = 0; i < 100; i++) {
	    double a = i*pi*2/100;
	    cerr << c.p.x+c.r*cos(a) << ' ' << c.p.y+c.r*sin(a) << endl;
	  }
	}
	cerr << endl << endl;
	for (Circle c : truth) {
	  cout << "Score: " << scoreCircle(c, points, 0.1) << endl;
	  cerr << c.p.x << ' ' << c.p.y << ' ' << endl;
	}
	return 0;
      }
    }
  }
}

#include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <sstream>
#include <stack>
#include <iomanip>
#include <assert.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef pair<int,int> pii;
typedef long long ll;
typedef double ld;
typedef vector<int> vi;
#define fi first
#define se second
#define fe first
#define FO(x) {freopen(#x".in","r",stdin);freopen(#x".out","w",stdout);}
#define Edg int M=0,fst[SZ],vb[SZ],nxt[SZ];void ad_de(int a,int b){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;}void adde(int a,int b){ad_de(a,b);ad_de(b,a);}
#define Edgc int M=0,fst[SZ],vb[SZ],nxt[SZ],vc[SZ];void ad_de(int a,int b,int c){++M;nxt[M]=fst[a];fst[a]=M;vb[M]=b;vc[M]=c;}void adde(int a,int b,int c){ad_de(a,b,c);ad_de(b,a,c);}
#define es(x,e) (int e=fst[x];e;e=nxt[e])
#define esb(x,e,b) (int e=fst[x],b=vb[e];e;e=nxt[e],b=vb[e])
#define SZ 2234567
int k,n,N;
//an old template
struct pnt
{
    ld x,y;
    pnt() {}
    pnt(ld a,ld b) {x=a; y=b;}
}p[SZ];
pnt operator - (pnt a,pnt b) {return pnt(a.x-b.x,a.y-b.y);}
ld operator * (pnt a,pnt b) {return a.x*b.y-a.y*b.x;}
ld pf(ld x) {return x*x;}
ld dis(pnt a,pnt b) {return sqrt(pf(a.x-b.x)+pf(a.y-b.y));}
pnt mid(pnt a,pnt b) {return pnt((a.x+b.x)/2,(a.y+b.y)/2);}
struct lne
{
    ld a,b,c;
    lne() {a=b=c=0;}
    lne(ld x,ld y,ld z) {a=x;b=y;c=z;}
};
ld dj(pnt a,pnt b)
{
	return a.x*b.x+a.y*b.y;
}
pnt operator * (lne a,lne b)
{
    return pnt((b.c*a.b-a.c*b.b)/(a.a*b.b-a.b*b.a),
                (a.c*b.a-b.c*a.a)/(a.a*b.b-a.b*b.a));
}
lne zcx(pnt a,pnt b)
{
    ld mx=(a.x+b.x)/2,my=(a.y+b.y)/2;
    ld la=a.x-b.x,lb=a.y-b.y,lc=-(mx*la+my*lb);
    return lne(la,lb,lc);
}
pnt wx(pnt a,pnt b,pnt c) {return zcx(a,b)*zcx(a,c);}
ld eps=1e-6;
pnt np(pnt a,pnt b,pnt c)
{
    if(fabs((b-a)*(c-a))<eps)
    {
        double abl=dis(a,b),acl=dis(a,c),bcl=dis(b,c),ans=-1;
        pnt ap;
        if(abl>ans) ans=abl, ap=mid(a,b);
        if(acl>ans) ans=acl, ap=mid(a,c);
        if(bcl>ans) ans=bcl, ap=mid(b,c);
        return ap;
    }
    return wx(a,b,c);
}
ld gr(pnt o,pnt a,pnt b,pnt c) {return max(max(dis(o,a),dis(o,b)),dis(o,c));}
pair<pnt,ld> rs[SZ]; int rn;
ld area(pnt a,pnt b,pnt c)
{
	return fabs((b-a)*(c-a));
}
bool in(pnt a,pnt b,pnt c,pnt o)
{
	return fabs(area(a,b,c)-
	area(a,b,o)-area(c,b,o)
	-area(a,c,o))<10;
}
ld dis(pair<pnt,ld> A,pair<pnt,ld> B)
{
	ld d=dis(A.fi,B.fi),r1=A.se,r2=B.se;
	ld d00=fabs(d+r1+r2),
	d01=fabs(d+r1-r2),
	d10=fabs(d-r1+r2),
	d11=fabs(d-r1-r2);
	//+: 0   -:1
	return max(max(min(d11,d10),
	min(d01,d00)),max(min(d11,d01),
	min(d10,d00)));
}
int ff[SZ];
int gf(int x) {return ff[x]?ff[x]=gf(ff[x]):x;}
pair<ld,pii> es[SZ]; int en;
const ld PI=acos(-1);
ld ang(pnt s)
{
	return atan2(s.y,s.x);
}
vector<int> ap[SZ];
int main()
{
	scanf("%d%d",&k,&n); N=k*n;
	for(int i=1;i<=N;++i)
		scanf("%lf%lf",&p[i].x,&p[i].y);
	random_shuffle(p+1,p+1+N);
	while(clock()<CLOCKS_PER_SEC*10)
	{
		int x=rand()%N+1,y=rand()%N+1,z=rand()%N+1;
		if(x==y||x==z||y==z) continue;
		if(rn>=2000) break;
		pnt o=np(p[x],p[y],p[z]);
		if(in(p[x],p[y],p[z],o));
		else continue;
		ld R=gr(o,p[x],p[y],p[z]);
		int cn=0;
		vector<ld> pr;
		pr.pb(-PI);
		pr.pb(PI);
		for(int j=1;j<=N;++j)
		{
			ld r=dis(o,p[j]);
			if(0.85*R<=r&&r<=1.15*R)
			{
				pr.pb(ang(p[j]-o));
				++cn;
			}
		}
		if(cn<n) continue;
		if(o.x*o.x+o.y*o.y<=1000000.0*1000000);
		else continue;
		if(R>=240000&&R<=760000);
		else continue;
		sort(pr.begin(),pr.end());
		bool bad=0;
		ld mx=0;
		for(int i=1;i<pr.size();++i)
			if(pr[i]-pr[i-1]>1)
				mx=max(mx,pr[i]-pr[i-1]),
				bad=1;
		if(bad) continue;
		/*
		{
			cout<<"FAKE!"<<mx<<"\n";
			for(auto g:pr)
				cerr<<g<<",";
			cerr<<"?\n";
			system("pause");
		}*/
		rs[++rn]=mp(o,R);
//		cerr<<cn<<"!";
	}
	for(int i=1;i<=rn;++i)
		for(int j=i+1;j<=rn;++j)
		{
			ld d=dis(rs[i],rs[j]);
			es[++en]=mp(d,pii(i,j));
		}
	sort(es+1,es+1+en);
	int tt=rn;
	for(int i=1;i<=en;++i)
	{
		int x=gf(es[i].se.fi),y=gf(es[i].se.se);
		if(x!=y)
		{
			--tt; ff[x]=y;
			if(tt==k) break;
		}
	}
	for(int i=1;i<=rn;++i) ap[gf(i)].pb(i);
	for(int i=1;i<=rn;++i)
		if(!ff[i])
		{
			ld mi=8e18; int X;
			for(auto x:ap[i])
			{
				ld dd=0;
				for(auto y:ap[i])
					dd+=dis(rs[x],rs[y]);
				if(dd<mi) mi=dd,X=x;
			}
//			cout<<i<<":"<<ap[i].size()<<"\n";
			printf("%.10lf %.10lf %.10lf\n",
			rs[X].fi.x,rs[X].fi.y,rs[X].se);
		}
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 2));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/*int t = 0;
	for(int i = 1; i <= k; i++) {
		double a = rd() * 3.1415926535, v = rd() * 1000000, x = cos(a) * v, y = sin(a) * v, r = fabs(rd()) * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -100; i <= 100; i++)
		for(int j = -100; j <= 100; j++) if(dis(0, 0, i * 10000, j * 10000) <= 1e6)
			Ansx[++cnt] = i * 10000, Ansy[cnt] = j  *10000, qwq[cnt] = getval(i * 10000, j * 10000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 4e5) qwq[i] = 1e100;
	}
	return 0;
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.2;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	srand(time(0));
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}
	n*=0.9;

	for (int h=0; h<k; h++)
	{
		vector <pair<pdd,ld>> kan;
		for (int h=0; h<20000; h++)
		{
			int ile=los(2, 5);
			vector <pdd> daj;
			for (int i=0; i<ile; i++)
				daj.push_back(znam[los(0, m-1)]);
			pdd x=sr(daj);
			ld y=0;
			for (pdd j : daj)
				y+=odl(j, x);
			y/=ile;
			kan.push_back({x, y});
		}
		int kto=-1;
		ld dokl=1e18;
		for (int i=0; i<(int)kan.size(); i++)
		{
			vector <ld> dys;
			for (int j=0; j<m; j++)
				dys.push_back(abs(kan[i].second-odl(kan[i].first, znam[j])));
			sort(dys.begin(), dys.end());
			ld x=dys[n-1];
			if (x<dokl)
			{
				dokl=x;
				kto=i;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		vector <pair<ld,pdd>>dys;
		for (int j=0; j<m; j++)
			dys.push_back({abs(kan[kto].second-odl(kan[kto].first, znam[j])), znam[j]});
		sort(dys.begin(), dys.end());
		znam.clear();
		for (int j=n; j<m; j++)
			znam.push_back(dys[j].second);
		m-=n;
	}
	return 0;
}

#include <bits/stdc++.h>
#define maxn 4005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.869, rs = 1.131;
int mn = maxn;
int n, k;
int fl[maxn];
bool check(cr a, pt b)
{
	db n1 = (a.u - b).len();
	return (n1 >= a.r * ls) && (n1 <= a.r * rs);
}
void cal(vector<pt> u)
{
	int lst = maxn;
	vector<pt> r;
	int tm = 0;
	while(1)
	{
		tm++;
		if(!(tm % 1000))
			if(clock() / CLOCKS_PER_SEC > 10) break;
		cr y[5];
		r = u;
		int fl = 1;
		for(int j = 1; j <= k; j++)
		{
			int ns = r.size();
			if(ns <= 3)
			{
				fl = 0;
				break;
			}
			l1:int u1 = rand() % ns, v = rand() % ns, w = rand() % ns;
			if(u1 == v || u1 == w || v == w) goto l1;
			pt a = r[u1], b = r[v], c = r[w];
			pt o = cer(a, b, c);
			y[j].u = o, y[j].r = (o - a).len();
			db u2 = (o - b).len();
			if(y[j].r > 750000 || y[j].r < 250000)
			{
				fl = 0;
				break;
			}
		//	if(abs(u2 - y[j].r) > 100) cout<<"WA"<<endl;
			vector<pt> g;
			for(int m = 0; m < ns; m++)
				if(!check(y[j], r[m])) g.push_back(r[m]);
			r = g;
		}
		if(!fl) continue;
		int ns[5] = {0, 0, 0, 0, 0};
		cr z[5];
		for(int i = 0; i < 5; i++)
			z[i].u = pt(0, 0),
			z[i].r = 0;
		vector<pt> s[5];
		for(int j = 0; j < u.size(); j++)
		{
			int nmm = maxn, mpl = 0;
			for(int t = 1; t <= k; t++)
				if(check(y[t], u[j]))
					if(ns[t] < nmm)
						nmm = ns[t], mpl = t;
			ns[mpl]++;
			s[mpl].push_back(u[j]);
		}

		int dv = 0;
		for(int j = 1; j <= k; j++)
			dv += abs(ns[j] - n);
		//if(dv < 10)
		if(dv < mn)
		{
			for(int i = 1; i <= k; i++)
			{
				z[i].u = y[i].u;
				for(int t = 0; t < s[i].size(); t++)
					z[i].r += (z[i].u - s[i][t]).len();
				z[i].r /= ns[i];
			}
	//		cout<<"!!!"<<dv<<" "<<y[1].u.x<<" "<<y[1].u.y<<" "<<y[1].r<<endl;
		//	for(int j = 0; j < u.size(); j++)
	//			cout<<check(y[1], u[j])<<" ";
	//		cout<<endl;
			mn = dv;
			for(int j = 1; j <= k; j++)
				x[j] = z[j];
		}

	}

}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);

	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(s);
	for(int i = 1; i <= k; i++)
		printf("%.10lf %.10lf %.10lf\n", x[i].u.x, x[i].u.y, x[i].r);
//	return 0;
	return 0;
}

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
#include <ctime>

using namespace std;
typedef long double ld;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const { return x*x + y*y; }
    double dist() const { return sqrt((double)dist2()); }
    // angle to x-axis in interval [-pi, pi]
    double angle() const { return atan2(y, x); }
    P unit() const { return *this/dist(); } // makes dist()=1
    P perp() const { return P(-y, x); } // rotates +90 degrees
    P normal() const { return perp().unit(); }
    // returns point rotated 'a' radians ccw around the origin
    P rotate(double a) const {
        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
};

typedef Point<double> P;
double ccRadius(const P& A, const P& B, const P& C) {
    return (B-A).dist()*(C-B).dist()*(A-C).dist()/
            abs((B-A).cross(C-A))/2;
}
P ccCenter(const P& A, const P& B, const P& C) {
    P b = C-A, c = B-A;
    return A + (b*c.dist2()-c*b.dist2()).perp()/b.cross(c)/2;
}

const int MAXN = 5000;

int N, K;
P pt[MAXN];

pair <P, double> res[4];

ld cdist (pair <P, double> left, pair <P, double> right)
{
    return abs(left.first.x - right.first.x) + abs (left.first.y - right.first.y) + abs(left.second - right.second);
}

void gogo()
{
    while (true)
    {
        int cval = 0;
        while (cval < K)
        {
            int a = rand() % (N * K), b = rand() % (N * K), c = rand() % (N * K);
            if (a == b || a == c || b == c) continue;
            if (!((pt[b]-pt[a]).cross(pt[c]-pt[a]))) continue;
            P cc = ccCenter(pt[a], pt[b], pt[c]);
            double rad = ccRadius(pt[a], pt[b], pt[c]);
            if (cc.dist() > 1050000 || rad < 200000 || rad > 800000) continue;

            bool bad = false;
            for (int i = 0; i < cval; i++)
            {
                if (cdist (res[i], make_pair (cc, rad)) < 350000)
                {
                    bad = true;
                    break;
                }
            }
            if (bad) continue;

            int nhit = 0;
            vector <double> v;
            for (int i = 0; i < N * K; i++)
            {
                double d = (cc-pt[i]).dist();
                if (d > 0.87 * rad && d < 1.13 * rad)
                {
                    nhit++;
                    v.push_back((cc-pt[i]).angle());
                }
            }
            sort(v.begin(), v.end());
            for (int i = 0; i + 1 < v.size(); i++)
                if (v[i+1] - v[i] > 1)
                {
                    //if (nhit >= N)
                    //    cout << v[i+1] - v[i] << "\n";
                    bad = true;
                }
            if (bad) continue;

            if (nhit >= N)
            {
                res[cval] = make_pair (cc, rad);
                cval++;
            }
        }

        bool bad = false;
        for (int i = 0; i < N * K; i++)
        {
            bool found = false;
            for (int j = 0; j < K; j++)
            {
                double d1 = res[j].second, d2 = (res[j].first-pt[i]).dist();
                if (d2 >= 0.8 * d1 && d2 <= 1.2 * d1)
                    found = true;
            }
            if (!found)
            {
                bad = true;
                break;
            }
        }
        if (!bad) break;
    }
}

int main()
{
    srand(time(NULL));
    cin >> K >> N;
    for (int i = 0; i < N * K; i++)
    {
        cin >> pt[i].x >> pt[i].y;
    }

    gogo();

    cout << fixed << setprecision(8);
    for (int i = 0; i < K; i++)
    {
        cout << res[i].first.x << " " << res[i].first.y << " " << res[i].second << "\n";
    }
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    point_t cen;
    for (point_t& p : pts) cin >> p.x >> p.y, cen = cen + p;
    cen = cen / n;
    vector<Circle> res;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, sz(pts)) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return 1e9;
        return abs(cnt - (double) sz(pts) / (k - sz(res)));
    };
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 10000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (5e4 < dist(pts[u], pts[v]) &&
                    5e4 < dist(pts[v], pts[w]) &&
                    5e4 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        Circle tmp;
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.1 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                tmp = c;
                break;
            }
        }
        res.pb(tmp);
        FORd(i, sz(pts), 0) {
            double d = dist(pts[i], res.back().cen);
            if (abs(d - res.back().rad) < 5e4) {
                pts.erase(pts.begin() + i);
            }
        }
        db(sz(pts)) endln;
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    point_t cen;
    for (point_t& p : pts) cin >> p.x >> p.y, cen = cen + p;
    cen = cen / n;
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 0.5 + point_t(500000, 500000));
    //}
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 1.5 + point_t(2 * 500000, 2 * 500000));
    //}
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 2.0 + point_t(3 * 500000, 3 * 500000));
    //}
    vector<Circle> res;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, sz(pts)) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return 1e9;
        return abs(cnt - (double) sz(pts) / (k - sz(res)));
    };
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 100000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (5e4 < dist(pts[u], pts[v]) &&
                    5e4 < dist(pts[v], pts[w]) &&
                    5e4 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        Circle tmp;
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.1 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                tmp = c;
                break;
            }
        }
        res.pb(tmp);
        FORd(i, sz(pts), 0) {
            double d = dist(pts[i], res.back().cen);
            if (abs(d - res.back().rad) < 5e4) {
                pts.erase(pts.begin() + i);
            }
        }
        db(sz(pts)) endln;
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    for (point_t& p : pts) cin >> p.x >> p.y;
    vector<Circle> res;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, sz(pts)) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return 1e9;
        return abs(cnt - (double) sz(pts) / (k - sz(res)));
    };
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 1000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (5e4 < dist(pts[u], pts[v]) &&
                    5e4 < dist(pts[v], pts[w]) &&
                    5e4 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        Circle tmp;
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.1 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                tmp = c;
                break;
            }
        }
        res.pb(tmp);
        FORd(i, sz(pts), 0) {
            double d = dist(pts[i], res.back().cen);
            if (abs(d - res.back().rad) < 5e4) {
                pts.erase(pts.begin() + i);
            }
        }
        db(sz(pts)) endln;
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    for (point_t& p : pts) cin >> p.x >> p.y;
    vector<Circle> res;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, sz(pts)) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return 1e9;
        return abs(cnt - (double) sz(pts) / (k - sz(res)));
    };
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 1000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (5e4 < dist(pts[u], pts[v]) &&
                    5e4 < dist(pts[v], pts[w]) &&
                    5e4 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        Circle tmp;
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.1 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                tmp = c;
                break;
            }
        }
        res.pb(tmp);
        FORd(i, sz(pts), 0) {
            double d = dist(pts[i], res.back().cen);
            if (abs(d - res.back().rad) < 5e4) {
                pts.erase(pts.begin() + i);
            }
        }
        db(sz(pts)) endln;
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#pragma GCC optimize ("O3")
#pragma GCC target ("sse4")

#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/rope>

using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;

typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;

typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef pair<ld,ld> pd;

typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;

template <class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;

#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i,a,b) for (int i = (b)-1; i >= (a); i--)
#define F0Rd(i,a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto& a : x)

#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound

#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize

const int MOD = 1000000007; // 998244353
const ll INF = 1e18;
const int MX = 200005;
const ld PI = 4*atan((ld)1);

template<class T> void ckmin(T &a, T b) { a = min(a, b); }
template<class T> void ckmax(T &a, T b) { a = max(a, b); }

namespace input {
    template<class T> void re(complex<T>& x);
    template<class T1, class T2> void re(pair<T1,T2>& p);
    template<class T> void re(vector<T>& a);
    template<class T, size_t SZ> void re(array<T,SZ>& a);

    template<class T> void re(T& x) { cin >> x; }
    void re(double& x) { string t; re(t); x = stod(t); }
    void re(ld& x) { string t; re(t); x = stold(t); }
    template<class Arg, class... Args> void re(Arg& first, Args&... rest) {
        re(first); re(rest...);
    }

    template<class T> void re(complex<T>& x) { T a,b; re(a,b); x = cd(a,b); }
    template<class T1, class T2> void re(pair<T1,T2>& p) { re(p.f,p.s); }
    template<class T> void re(vector<T>& a) { F0R(i,sz(a)) re(a[i]); }
    template<class T, size_t SZ> void re(array<T,SZ>& a) { F0R(i,SZ) re(a[i]); }
}

using namespace input;

namespace output {
    template<class T1, class T2> void pr(const pair<T1,T2>& x);
    template<class T, size_t SZ> void pr(const array<T,SZ>& x);
    template<class T> void pr(const vector<T>& x);
    template<class T> void pr(const set<T>& x);
    template<class T1, class T2> void pr(const map<T1,T2>& x);

    template<class T> void pr(const T& x) { cout << x; }
    template<class Arg, class... Args> void pr(const Arg& first, const Args&... rest) {
        pr(first); pr(rest...);
    }

    template<class T1, class T2> void pr(const pair<T1,T2>& x) {
        pr("{",x.f,", ",x.s,"}");
    }
    template<class T> void prContain(const T& x) {
        pr("{");
        bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0; // const needed for vector<bool>
        pr("}");
    }
    template<class T, size_t SZ> void pr(const array<T,SZ>& x) { prContain(x); }
    template<class T> void pr(const vector<T>& x) { prContain(x); }
    template<class T> void pr(const set<T>& x) { prContain(x); }
    template<class T1, class T2> void pr(const map<T1,T2>& x) { prContain(x); }

    void ps() { pr("\n"); }
    template<class Arg> void ps(const Arg& first) {
        pr(first); ps(); // no space at end of line
    }
    template<class Arg, class... Args> void ps(const Arg& first, const Args&... rest) {
        pr(first," "); ps(rest...); // print w/ spaces
    }
}

using namespace output;

namespace io {
    void setIn(string s) { freopen(s.c_str(),"r",stdin); }
    void setOut(string s) { freopen(s.c_str(),"w",stdout); }
    void setIO(string s = "") {
        ios_base::sync_with_stdio(0); cin.tie(0); // fast I/O
        if (sz(s)) { setIn(s+".in"), setOut(s+".out"); } // for USACO
    }
}

using namespace io;

template<class T> T invGeneral(T a, T b) {
    a %= b; if (a == 0) return b == 1 ? 0 : -1;
    T x = invGeneral(b,a);
    return x == -1 ? -1 : ((1-(ll)b*x)/a+b)%b;
}

template<class T> struct modular {
    T val;
    explicit operator T() const { return val; }
    modular() { val = 0; }
    template<class U> modular(const U& v) {
        val = (-MOD <= v && v <= MOD) ? v : v % MOD;
        if (val < 0) val += MOD;
    }
    friend ostream& operator<<(ostream& os, const modular& a) { return os << a.val; }
    friend bool operator==(const modular& a, const modular& b) { return a.val == b.val; }
    friend bool operator!=(const modular& a, const modular& b) { return !(a == b); }

    modular operator-() const { return modular(-val); }
    modular& operator+=(const modular& m) { if ((val += m.val) >= MOD) val -= MOD; return *this; }
    modular& operator-=(const modular& m) { if ((val -= m.val) < 0) val += MOD; return *this; }
    modular& operator*=(const modular& m) { val = (ll)val*m.val%MOD; return *this; }
    friend modular exp(modular a, ll p) {
        modular ans = 1; for (; p; p /= 2, a *= a) if (p&1) ans *= a;
        return ans;
    }
    friend modular inv(const modular& a) {
        auto i = invGeneral(a.val,MOD); assert(i != -1);
        return i;
    } // equivalent to return exp(b,MOD-2) if MOD is prime
    modular& operator/=(const modular& m) { return (*this) *= inv(m); }

    friend modular operator+(modular a, const modular& b) { return a += b; }
    friend modular operator-(modular a, const modular& b) { return a -= b; }
    friend modular operator*(modular a, const modular& b) { return a *= b; }

    friend modular operator/(modular a, const modular& b) { return a /= b; }
};

typedef modular<int> mi;
typedef pair<mi,mi> pmi;
typedef vector<mi> vmi;
typedef vector<pmi> vpmi;

typedef double T;

namespace Point {
    typedef pair<T,T> P;
    typedef vector<P> vP;

    /*P dir(T ang) {
        cd c = exp(ang*cd(0,1));
        return P(c.real(),c.imag());
    }*/

    T norm(P x) { return x.f*x.f+x.s*x.s; }
    T abs(P x) { return sqrt(norm(x)); }
    T angle(P x) { return atan2(x.s,x.f); }
    P conj(P x) { return P(x.f,-x.s); }

    P operator+(const P& l, const P& r) { return P(l.f+r.f,l.s+r.s); }
    P operator-(const P& l, const P& r) { return P(l.f-r.f,l.s-r.s); }
    P operator*(const P& l, const T& r) { return P(l.f*r,l.s*r); }
    P operator*(const T& l, const P& r) { return r*l; }
    P operator/(const P& l, const T& r) { return P(l.f/r,l.s/r); }
    P operator*(const P& l, const P& r) { return P(l.f*r.f-l.s*r.s,l.s*r.f+l.f*r.s); }
    P operator/(const P& l, const P& r) { return l*conj(r)/norm(r); }

    P& operator+=(P& l, const P& r) { return l = l+r; }
    P& operator-=(P& l, const P& r) { return l = l-r; }
    P& operator*=(P& l, const T& r) { return l = l*r; }
    P& operator/=(P& l, const T& r) { return l = l/r; }
    P& operator*=(P& l, const P& r) { return l = l*r; }
    P& operator/=(P& l, const P& r) { return l = l/r; }

    P unit(P x) { return x/abs(x); }
    T dot(P a, P b) { return (conj(a)*b).f; }
    T cross(P a, P b) { return (conj(a)*b).s; }
    T cross(P p, P a, P b) { return cross(a-p,b-p); }
    T dist(P p, P a, P b) { return std::abs(cross(p,a,b))/abs(a-b); }

    P rotate(P a, T b) { return a*P(cos(b),sin(b)); }
    P reflect(P p, P a, P b) { return a+conj((p-a)/(b-a))*(b-a); }
    P foot(P p, P a, P b) { return (p+reflect(p,a,b))/(T)2; }
    P extension(P a, P b, P c, P d) {
        T x = cross(a,b,c), y = cross(a,b,d);
        return (d*x-c*y)/(x-y);
    }
    // computes the intersection of line segments AB, CD
    // verification: https://open.kattis.com/problems/segmentintersection
    vP segIntersect(P a, P b, P c, P d) {
        if (a > b) swap(a,b);
        if (c > d) swap(c,d);

        auto a1 = cross(a,b,c), a2 = cross(a,b,d);
        if (a1 > a2) swap(a1,a2);
        if (!(a1 <= 0 && a2 >= 0)) return {};

        if (a1 == 0 && a2 == 0) {
            if (cross(a,c,d) != 0) return {};
            auto x1 = max(a,c), x2 = min(b,d);
            if (x1 > x2) return {};
            if (x1 == x2) return {x1};
            return {x1,x2};
        }

        auto z = extension(a,b,c,d);
        if (a <= z && z <= b) return {z};
        return {};
    }

    // sorts points according to atan2
    // verification: ?
    template<class T> int half(pair<T,T> x) { return mp(x.s,x.f) > mp((T)0,(T)0); }
    bool cmp(P a, P b) {
        int A = half(a), B = half(b);
        if (A != B) return A < B;
        return cross(a,b) > 0;
    }

    // computes the center of mass of a polygon with constant mass per unit area
    // verification: kattis polygonarea, VT HSPC 2018 Holiday Stars
    T area(const vP& v) {
        T area = 0;
        F0R(i,sz(v)) {
            int j = (i+1)%sz(v); T a = cross(v[i],v[j]);
            area += a;
        }
        return std::abs(area)/2;
    }
    P centroid(const vP& v) {
        P cen(0,0); T area = 0; // 2*signed area
        F0R(i,sz(v)) {
            int j = (i+1)%sz(v); T a = cross(v[i],v[j]);
            cen += a*(v[i]+v[j]); area += a;
        }
        return cen/area/(T)3;
    }

    // tests whether a point is inside, on, or outside the perimeter of any polygon
    // verification: https://open.kattis.com/problems/pointinpolygon
    string inPoly(const vP& p, P z) {
        int n = sz(p), ans = 0;
        F0R(i,n) {
            P x = p[i], y = p[(i+1)%n];
            if (cross(x,y,z) == 0 && min(x,y) <= z && z <= max(x,y)) return "on";
            if (x.s > y.s) swap(x,y);
            if (x.s <= z.s && y.s > z.s && cross(z,x,y) > 0) ans ^= 1;
        }
        return ans ? "in" : "out";
    }

    pair<P,double> ccCenter(P a, P b, P c) { // circumcenter
        b -= a; c -= a;
        P res = b*c*(conj(c)-conj(b))/(b*conj(c)-conj(b)*c);
        return {a+res,abs(res)};
    }

    pair<P, double> mec(vP ps) { // minimum enclosing circle, ex. USACO Camp 2019 Contest 2 #4
        shuffle(all(ps), mt19937(time(0)));
        P o = ps[0]; double r = 0, EPS = 1 + 1e-8;
        F0R(i,sz(ps)) if (abs(o-ps[i]) > r*EPS) {
            o = ps[i], r = 0;
            F0R(j,i) if (abs(o-ps[j]) > r*EPS) {
                o = (ps[i]+ps[j])/2, r = abs(o-ps[i]);
                F0R(k,j) if (abs(o-ps[k]) > r*EPS)
                    tie(o,r) = ccCenter(ps[i],ps[j],ps[k]);
            }
        }
        return {o,r};
    }
};

using namespace Point;

int k,n;
vP v;

vP group[4], lef;
pair<P,T> circ[4];

pair<P,T> approx(vP v) {
    int num = 0;
    P sum = {0,0};
    F0R(i,50) {
        P x = v[rand()%sz(v)], y = v[rand()%sz(v)], z = v[rand()%sz(v)];
        if (cross(x,y,z) == 0 || ccCenter(x,y,z).s > 1000000) continue;
        sum += ccCenter(x,y,z).f; num ++;
    }
    sum /= (double)num;
    double dist = 0;
    trav(t,v) dist += abs(sum-t);
    dist /= sz(v);
    return {sum,dist};
}

void fin() {
	cout << fixed << setprecision(8);
	F0R(i,k) ps(circ[i].f.f,circ[i].f.s,circ[i].s);
	exit(0);
}

double val(pair<P,T> c, P t) {
	double x = abs(c.f-t);
	if (x < 0.8*c.s || x > 1.2*c.s) return MOD;
	return abs(x-c.s);
}

void test() {
	F0R(i,k) group[i].clear();
	lef.clear();
    F0R(i,n) group[rand()%k].pb(v[i]);

    F0R(i,200) {
        F0R(j,k) if (sz(group[j]) <= 5) return;
        if (i > 0 && sz(lef) == 0) fin();
        F0R(j,k) {
            circ[j] = approx(group[j]);
            group[j].clear();
        }
        lef.clear();
        trav(t,v) {
            pair<double,int> bes = {MOD,MOD};
            F0R(j,k) ckmin(bes,{val(circ[j],t),j});
            if (bes.f == MOD) lef.pb(t);
            else group[bes.s].pb(t);
        }
    }
}

int main() {
    setIO(); re(k,n); v.rsz(n*k); re(v);
    // ps(v);
    while (1) test();
}

/* stuff you should look for
    * int overflow, array bounds
    * special cases (n=1?), set tle
    * do smth instead of nothing and stay organized
*/

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
mt19937 mt(736);

using point = pair<double, double>;
using ipoint = pair<int, int>;

const int miss = 30000;

ipoint operator-(ipoint a, ipoint b)
{
	return {a.first - b.first, a.second - b.second};
}

template<class T>
T dist(T d, T r1, T r2)
{
	auto ans = numeric_limits<T>::max();

	for (int a : {-1, 1})
		for (int b : {-1, 1})
			ans = min(ans, d + a * r1 + b * r2);

	return ans;
}

template<class T>
T sqr(T x)
{
	return x * x;
}

double len2(ipoint A)
{
	return sqr((ll) A.first) + sqr((ll) A.second);
}

point circumcircle(ipoint A, ipoint B, ipoint C)
{
	auto D = A.first * (B.second - (double) C.second) + B.first * (C.second - (double) A.second) +
	         C.first * (A.second - (double) B.second);
	D *= 2;

	double x = (len2(A) * (B.second - C.second) + (len2(B)) * (C.second - A.second) +
	            len2(C) * (A.second - B.second)) / D;
	double y = (len2(A) * (C.first - B.first) + len2(B) * (A.first - C.first) +
	            len2(C) * (B.first - A.first)) / D;

	ipoint U(x, y);

	if (max(abs(x), abs(y)) > 1e6 || len2(U) > 1e12)
		return {numeric_limits<int>::max(), numeric_limits<int>::max()};
	return U;
}

void solve(istream &cin = std::cin, ostream &cout = std::cout)
{
	int k, n;

	cin >> k >> n;

	vector<ipoint> pts(n * k);

	for (auto &it : pts)
		cin >> it.first >> it.second;

	shuffle(pts.begin(), pts.end(), mt);

	while (true)
	{
		vector<ipoint> bad = pts;
		vector<pair<ipoint, int>> centers;

		for (int i = 0; i < 1e3 && !bad.empty(); i++)
		{
			shuffle(bad.begin(), bad.end(), mt);

			if (bad.size() < 3)
			{
				// do something
				break;
			}
			else
			{
				auto cent = circumcircle(bad[0], bad[1], bad[2]);

				if (cent.first != numeric_limits<int>::max())
				{
					int r = (int) round(sqrt(len2(cent - bad[0])));
					int cnt = 0;

					r = min(r, 750000);
					r = max(r, 250000);

					for (auto it : pts)
						if (abs(sqrt(len2(cent - it)) - r) <= 0.1 * r + miss)
							cnt++;

					if (cnt >= n)
					{
						if (centers.size() < k)
						{
							centers.emplace_back(cent, r);
						}
						else
						{
							vector<int> d(k);

							for (int j = 0; j < k; j++)
								d[j] = dist((int) sqrt(len2(centers[j].first - cent)), centers[j].second, r);

							int wh = min_element(d.begin(), d.end()) - d.begin();

							centers[wh].first.first = (centers[wh].first.first + cent.first) / 2;
							centers[wh].first.second = (centers[wh].first.second + cent.second) / 2;
							centers[wh].second = (centers[wh].second + r) / 2;
						}
					}
				}
			}

			bad.clear();

			for (auto it : pts)
			{
				bool good = false;

				for (auto cent : centers)
				{
					if (abs(sqrt(len2(cent.first - it)) - cent.second) <= 0.1 * cent.second + miss)
					{
						good = true;
						break;
					}
				}

				if (!good)
					bad.push_back(it);
			}
		}

		if (bad.empty() && centers.size() == k)
		{
			for (auto it : centers)
				cout << it.first.first << ' ' << it.first.second << ' ' << it.second << endl;

			return;
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	cout << fixed;

#ifdef LOCAL
	ifstream fin("../input.txt");

	solve(fin);

	cout << setprecision(4);
	cout << "clock: " << clock() / (double) CLOCKS_PER_SEC << endl;
#else
	solve();
#endif

	return 0;
}

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;

#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
int gcd(int a,int b) { return b==0?a:gcd(b,a%b); }

const int MAXRING=4;
const int MAXEACH=1000;
const int MAXN=MAXRING*MAXEACH;
const double M_PI=acos(-1.0);
struct P { double x,y; P() {} P(double x,double y):x(x),y(y) {} };
struct Circle { P center; double r; Circle() {} Circle(P center,double r):center(center),r(r) {} };

double dist(const P &a,const P &b) { double dx=a.x-b.x,dy=a.y-b.y; return sqrt(dx*dx+dy*dy); }

int nring,neach,n;
P p[MAXN];

std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());

bool makecircle(const P &a,const P &b,const P &c,P &center,double &r) {
	double denx=2*(a.y*(c.x-b.x)+b.y*(a.x-c.x)+c.y*(b.x-a.x));
	double deny=2*(a.x*(c.y-b.y)+b.x*(a.y-c.y)+c.x*(b.y-a.y));
	if(fabs(denx)<1e-3||fabs(deny)<1e-3) return false;
	double cx2=c.x*c.x,bx2=b.x*b.x,cy2=c.y*c.y,by2=b.y*b.y,ax2=a.x*a.x,ay2=a.y*a.y;
	double numx=a.y*(cx2-bx2+cy2-by2)+b.y*(ax2-cx2+ay2-cy2)+c.y*(bx2-ax2+by2-ay2);
	double numy=a.x*(cx2-bx2+cy2-by2)+b.x*(ax2-cx2+ay2-cy2)+c.x*(bx2-ax2+by2-ay2);
	center=P(numx/denx,numy/deny); r=(dist(a,center)+dist(b,center)+dist(c,center))/3;
	return true;
}

vector<Circle> cans;
vector<pair<Circle,double>> opt;

double dist(const Circle &a,const Circle &b) {
	double d=dist(a.center,b.center);
	vector<double> v(4); REP(i,4) { double cur=d; if((i&1)==0) cur+=a.r; else cur-=a.r; if((i&2)==0) cur+=b.r; else cur-=b.r; v[i]=abs(cur); }
	double ret=0; REP(i,4) REP(diff,2) { int j=i^(1<<diff); ret=max(ret,min(v[i],v[j])); } return ret;
}

double calc(const Circle &c,const P &p) { return fabs(dist(c.center,p)-c.r); }
void addopt(Circle c) {
	vector<double> cur; REP(j,n) cur.PB(calc(c,p[j])); sort(cur.begin(),cur.end()); double sum=0; REP(j,neach) sum+=cur[j]; sum/=neach; //if(ismissing) printf("%lf\n",sum);
	if(SZ(opt)<nring) { opt.PB(MP(c,sum)); /*printf("%lf\n",sum);*/ return; }
	//bool ismissing=false; REPSZ(i,cans) { bool have=false; REPSZ(j,opt) if(dist(cans[i],opt[j].first)<100000) have=true; if(!have&&dist(cans[i],c)<100000) ismissing=true; }
	double bestval=1e200; int bestreplace=-1;
	REPSZ(replace,opt) {
		double before=0,after=0;
		REP(j,n) {
			double have=1e200; REPSZ(i,opt) if(i!=replace) have=min(have,calc(opt[i].first,p[j]));
			before+=min(have,calc(opt[replace].first,p[j])); after+=min(have,calc(c,p[j]));
		}
		//if(ismissing) printf("before=%lf after=%lf\n",before,after);
		if(after<before&&after<bestval) bestval=after,bestreplace=replace;
	}
	if(bestreplace!=-1) {
		//printf("replacing %lf with %lf\n",opt[bestreplace].second,sum);
		opt[bestreplace]=MP(c,sum);
	} else {
		//if(ismissing) printf("skipping %lf\n",sum);
	}
}

void solve() {
	vector<pair<Circle,double>> bestopt; double bestval=1e200;
	REP(rep,10) {
		opt.clear();
		REP(i,1000) {
			int a=rnd()%n,b=rnd()%n,c=rnd()%n; if(b==a||c==a||c==b) continue;
			P center; double r; if(!makecircle(p[a],p[b],p[c],center,r)) continue;
			addopt(Circle(center,r));
			//printf("(%lf,%lf) rad=%lf sum=%lf\n",center.x,center.y,r,sum);
		}
		assert(SZ(opt)==nring);
		double curval=0; REP(j,n) { double me=1e200; REPSZ(i,opt) me=min(me,calc(opt[i].first,p[j])); curval+=me; }
		if(curval<bestval) bestval=curval,bestopt=opt;
	}
	opt=bestopt;
}

void run() {
	scanf("%d%d",&nring,&neach); n=nring*neach;
	REP(i,n) scanf("%lf%lf",&p[i].x,&p[i].y);
	solve();
	REPSZ(i,opt) printf("%lf %lf %lf\n",opt[i].first.center.x,opt[i].first.center.y,opt[i].first.r);
}

void stress() {
	std::mt19937 genrnd(12312);
	const double omx=1000000;
	std::uniform_real_distribution<double> gensquare(-omx, omx);
	std::uniform_real_distribution<double> genradius(250000, 750000);
	std::uniform_real_distribution<double> genang(0, 2*M_PI);
	std::uniform_real_distribution<double> genmlt(0.9,1.1);
	int mxring=4;
	REP(rep,100) {
		nring=genrnd()%mxring+1;
		neach=genrnd()%(1000-100+1)+100;
		n=nring*neach;
		vector<Circle> c(nring);
		REP(i,nring) {
			while(true) {
				double cx=gensquare(genrnd),cy=gensquare(genrnd); if(cx*cx+cy*cy>omx*omx) continue;
				c[i].center=P(cx,cy);
				c[i].r=genradius(genrnd);
				//printf("testing (%lf,%lf,%lf)\n",c[i].center.x,c[i].center.y,c[i].r);
				bool ok=true; REP(j,i) if(dist(c[i],c[j])<600000) ok=false; if(!ok) continue;
				break;
			}

			REP(j,neach) {
				double ang=genang(genrnd),mlt=genmlt(genrnd);
				double x=floor(c[i].center.x+mlt*c[i].r*cos(ang)+.5),y=floor(c[i].center.y+mlt*c[i].r*sin(ang)+.5);
				p[i*neach+j]=P(x,y);
			}
		}
		shuffle(p,p+n,genrnd);
		cans=c;
		//if(rep!=29) continue;
		rnd=genrnd;
		solve();
		vector<int> perm(nring); REP(i,nring) perm[i]=i;
		double best=1e200; vector<int> bestperm;
		do {
			double cur=0; REP(i,nring) cur=max(cur,dist(c[i],opt[perm[i]].first)); if(cur<best) best=cur,bestperm=perm;
		} while(next_permutation(perm.begin(),perm.end()));
		printf("want:"); REP(i,nring) printf(" (x-%.0lf)^2+(y-%.0lf)^2=%.0lf^2",c[i].center.x,c[i].center.y,c[i].r); puts("");
		printf("have:"); REP(i,nring) printf(" (x-%.0lf)^2+(y-%.0lf)^2=%.0lf^2",opt[bestperm[i]].first.center.x,opt[bestperm[i]].first.center.y,opt[bestperm[i]].first.r); puts("");
		printf("rep=%d best=%lf\n",rep,best);
		if(best>400000) return;

	}
}

int main() {
	run();
	//stress();
	return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 14; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    //srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.02);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 2 * (k - cc) + 6; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    //srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    //random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.0025);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 2 * (k - cc) + 6; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    //srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.004);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 14; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    //srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.03);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 2 * (k - cc) + 6; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    //srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.02);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    bool operator < (const pnt &b) const {
        return abs(x - b.x) > ep ? x < b.x : y < b.y;
    }
    bool operator == (const pnt &b) {
        return abs(x - b.x) < ep && abs(y - b.y) < ep;
    }
    bool operator != (const pnt &b) {
        return abs(x - b.x) > ep || abs(y - b.y) > ep;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 9; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.1);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 2 * (k - cc) + 7; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.0025);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 12; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.03);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 13; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.05);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 13; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.01);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 13; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.02);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 14; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    //srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.02);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    bool operator < (const pnt &b) const {
        return abs(x - b.x) > ep ? x < b.x : y < b.y;
    }
    bool operator == (const pnt &b) {
        return abs(x - b.x) < ep && abs(y - b.y) < ep;
    }
    bool operator != (const pnt &b) {
        return abs(x - b.x) > ep || abs(y - b.y) > ep;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    if (cnt < 0.6 * n) return 0;
//    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 9; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.1);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 9; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.03);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 14; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    srand(time(0));
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.03);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

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

#define N 10010

int k, n;

const double ep = 1e-8;
const double pi = 3.14159265358979323846264338327950288L;
struct pnt {
    double x, y;
    pnt(double x = 0, double y = 0) : x(x), y(y) {}
    pnt operator + (const pnt &b) {
        return pnt(x + b.x, y + b.y);
    }
    pnt operator - (const pnt &b) {
        return pnt(x - b.x, y - b.y);
    }
    pnt operator * (const double &b) {
        return pnt(x * b, y * b);
    }
    pnt operator / (const double &b) {
        return pnt(x / b, y / b);
    }
    double operator & (const pnt &b) {
        return x * b.x + y * b.y;
    }
    double operator ^ (const pnt &b) {
        return x * b.y - b.x * y;
    }
    pnt rot() {
        return pnt(-y, x);
    }
    friend double dist(pnt a) {
        return sqrt(a.x * a.x + a.y * a.y);
    };
    void input() {
        scanf("%lf %lf", &x, &y);
    }
    void print() {
        printf("%.12lf %.12lf ", x, y);
    }
} p[N];

pnt outc(pnt a, pnt b, pnt c) {
    return (a + b + (b - a).rot() * (a - c & b - c) / (a - c ^ b - c)) / 2;
}

bool vis[N];

double del;

bool check(pnt O, double r, vector <int> &rlt) {
    if (dist(O) > 1000100 || r < 240000 || r > 760000) return 0;
    int cnt = 0; vector <int> cur;
    for (int i = 0; i < n * k; i ++) {
        if (vis[i]) continue;
        double d = dist(O - p[i]);
        if (0.9 * r <= d && d <= 1.1 * r) cnt ++, cur.push_back(i);
    }
    //if (cnt < 0.6 * n) return 0;
    if (cnt < del * n) return 0;
//    for (int i = 0; i < n * k; i ++) {
//        if (vis[i]) continue;
//        double d = dist(O - p[i]);
//        if (0.9 * r <= d && d <= 1.1 * r) cout << d << ' ' << r << endl;
//    }
    random_shuffle(cur.begin(), cur.end()); rlt.clear();
    for (int i = 0; i < cnt && i < n; i ++) vis[cur[i]] = 1, rlt.push_back(cur[i]);
    return 1;
}

vector <pnt> ans;
vector <double> ans_r;

bool solve(int cc) {
    if (cc == k) return 1;
    vector <int> vec;
    for (int j = 0; j < n * k && vec.size() < 9; j ++) if (!vis[j]) vec.push_back(j);
    int sz = vec.size();
    for (int a = 0; a < sz; a ++) {
        for (int b = 0; b < a; b ++) {
            for (int c = 0; c < b; c ++) {
                pnt O = outc(p[vec[a]], p[vec[b]], p[vec[c]]);
                for (int x = -0; x <= 0; x ++) {
                    for (int y = -0; y <= 0; y ++) {
                        pnt P = O; P.x += x, P.y += y;
                        double r = dist(P - p[vec[a]]);
                        vector <int> vec;
                        if (check(P, r, vec)) {
                            ans[cc] = P, ans_r[cc] = r;
                            if (solve(cc + 1)) return 1;
                            int sz = vec.size();
                            for (int j = 0; j < sz; j ++) vis[vec[j]] = 0;
                        }
                    }
                }
            }
        }
    }
    return 0;
}

int main() {
    scanf("%d %d", &k, &n);
    for (int i = 0; i < n * k; i ++) p[i].input();
    random_shuffle(p, p + n * k);
    ans.resize(k), ans_r.resize(k);
    for (del = 1.0; !solve(0); del -= 0.003);
    for (int i = 0; i < k; i ++) ans[i].print(), printf("%.12lf\n", ans_r[i]);
    return 0;
}

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.898, rs = 1.102;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = ns / k;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 230000 || r > 770000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 11000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db long double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
//	cout<<c2<<endl;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
//	cout<<n1<<" "<<n2<<" "<<n3<<endl;
	fn = fn * (1 / (n1 + n2 + n3));
//	cout<<fn.x<<" "<<fn.y<<endl;
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.8999, rs = 1.1001;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
	//	if(abs(r - rs) < 1) cout<<"WA"<<" "<<r<<" "<<rs<<endl;
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if((n1 >= ls * r) && (n1 <= rs * r))
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
	//	cout<<mx<<endl;
		if(tm > 8000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
//	pt a = pt(0, 0), b = pt(0, 3), c = pt(4, 5);
//	pt o = cer(a, b, c);
//	cout<<(o - a).len()<<" "<<(o - b).len()<<" "<<(o - c).len()<<endl;
//	while(1);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 4005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
int mn = maxn;
int n, k;
int fl[maxn];
bool check(cr a, pt b)
{
	db n1 = (a.u - b).len();
	return (n1 >= a.r * ls) && (n1 <= a.r * rs);
}
void cal(vector<pt> u)
{
	int lst = maxn;
	vector<pt> r;
	int tm = 0;
	while(1)
	{
		tm++;
		if(!(tm % 1000))
			if(clock() / CLOCKS_PER_SEC > 10) break;
		cr y[5];
		r = u;
		int fl = 1;
		for(int j = 1; j <= k; j++)
		{
			int ns = r.size();
			if(ns <= 3)
			{
				fl = 0;
				break;
			}
			l1:int u1 = rand() % ns, v = rand() % ns, w = rand() % ns;
			if(u1 == v || u1 == w || v == w) goto l1;
			pt a = r[u1], b = r[v], c = r[w];
			pt o = cer(a, b, c);
			y[j].u = o, y[j].r = (o - a).len();
			db u2 = (o - b).len();
			if(y[j].r > 750000 || y[j].r < 250000)
			{
				fl = 0;
				break;
			}
		//	if(abs(u2 - y[j].r) > 100) cout<<"WA"<<endl;
			vector<pt> g;
			for(int m = 0; m < ns; m++)
				if(!check(y[j], r[m])) g.push_back(r[m]);
			r = g;
		}
		if(!fl) continue;
		int ns[5] = {0, 0, 0, 0, 0};
		for(int j = 0; j < u.size(); j++)
		{
			int nmm = maxn, mpl = 0;
			for(int t = 1; t <= k; t++)
				if(check(y[t], u[j]))
					if(ns[t] < nmm)
						nmm = ns[t], mpl = t;
			ns[mpl]++;
		}
		int dv = 0;
		for(int j = 1; j <= k; j++)
			dv += abs(ns[j] - n);
		//if(dv < 10)
		if(dv < mn)
		{
	//		cout<<"!!!"<<dv<<" "<<y[1].u.x<<" "<<y[1].u.y<<" "<<y[1].r<<endl;
		//	for(int j = 0; j < u.size(); j++)
	//			cout<<check(y[1], u[j])<<" ";
	//		cout<<endl;
			mn = dv;
			for(int j = 1; j <= k; j++)
				x[j] = y[j];
		}

	}

}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);

	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(s);
	for(int i = 1; i <= k; i++)
		printf("%.10lf %.10lf %.10lf\n", x[i].u.x, x[i].u.y, x[i].r);
	return 0;
	return 0;
}

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = 0;
	int tm = 0;
	cr nu;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		db r = (o - a).len();
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= 0.89 * r && n1 <= 1.11 * r)
				sm++;
		}
		if(sm > mx)
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 8000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= 0.89 * nu.r && n1 <= 1.11 * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 4005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
int mn = maxn;
int n, k;
int fl[maxn];
bool check(cr a, pt b)
{
	db n1 = (a.u - b).len();
	return (n1 >= a.r * ls) && (n1 <= a.r * rs);
}
void cal(vector<pt> u)
{
	int lst = maxn;
	vector<pt> r;
	int tm = 0;
	while(1)
	{
		tm++;
		if(!(tm % 1000))
			if(clock() / CLOCKS_PER_SEC > 1) break;
		cr y[5];
		r = u;
		int fl = 1;
		for(int j = 1; j <= k; j++)
		{
			int ns = r.size();
			if(ns <= 3)
			{
				fl = 0;
				break;
			}
			l1:int u1 = rand() % ns, v = rand() % ns, w = rand() % ns;
			if(u1 == v || u1 == w || v == w) goto l1;
			pt a = r[u1], b = r[v], c = r[w];
			pt o = cer(a, b, c);
			y[j].u = o, y[j].r = (o - a).len();
			db u2 = (o - b).len();
			if(y[j].r > 750000 || y[j].r < 250000)
			{
				fl = 0;
				break;
			}
		//	if(abs(u2 - y[j].r) > 100) cout<<"WA"<<endl;
			vector<pt> g;
			for(int m = 0; m < ns; m++)
				if(!check(y[j], r[m])) g.push_back(r[m]);
			r = g;
		}
		if(!fl) continue;
		int ns[5] = {0, 0, 0, 0, 0};
		for(int j = 0; j < u.size(); j++)
		{
			int nmm = maxn, mpl = 0;
			for(int t = 1; t <= k; t++)
				if(check(y[t], u[j]))
					if(ns[t] < nmm)
						nmm = ns[t], mpl = t;
			ns[mpl]++;
		}
		int dv = 0;
		for(int j = 1; j <= k; j++)
			dv += abs(ns[j] - n);
		//if(dv < 10)
		if(dv < mn)
		{
	//		cout<<"!!!"<<dv<<" "<<y[1].u.x<<" "<<y[1].u.y<<" "<<y[1].r<<endl;
		//	for(int j = 0; j < u.size(); j++)
	//			cout<<check(y[1], u[j])<<" ";
	//		cout<<endl;
			mn = dv;
			for(int j = 1; j <= k; j++)
				x[j] = y[j];
		}

	}

}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);

	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(s);
	for(int i = 1; i <= k; i++)
		printf("%.10lf %.10lf %.10lf\n", x[i].u.x, x[i].u.y, x[i].r);
	return 0;
	return 0;
}

#include <bits/stdc++.h>
#define maxn 1005
#define db long double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
//	cout<<c2<<endl;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
//	cout<<n1<<" "<<n2<<" "<<n3<<endl;
	fn = fn * (1 / (n1 + n2 + n3));
//	cout<<fn.x<<" "<<fn.y<<endl;
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.8999, rs = 1.1001;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.4;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
	//	if(abs(r - rs) < 1) cout<<"WA"<<" "<<r<<" "<<rs<<endl;
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if((n1 >= ls * r) && (n1 <= rs * r))
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
	//	cout<<mx<<endl;
		if(tm > 5000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
//	pt a = pt(0, 0), b = pt(0, 3), c = pt(4, 5);
//	pt o = cer(a, b, c);
//	cout<<(o - a).len()<<" "<<(o - b).len()<<" "<<(o - c).len()<<endl;
//	while(1);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 6000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 4005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.88, rs = 1.12;
int mn = maxn;
int n, k;
int fl[maxn];
bool check(cr a, pt b)
{
	db n1 = (a.u - b).len();
	return (n1 >= a.r * ls) && (n1 <= a.r * rs);
}
void cal(vector<pt> u)
{
	int lst = maxn;
	vector<pt> r;
	int tm = 0;
	while(1)
	{
		tm++;
		if(!(tm % 1000))
			if(clock() / CLOCKS_PER_SEC > 10) break;
		cr y[5];
		r = u;
		int fl = 1;
		for(int j = 1; j <= k; j++)
		{
			int ns = r.size();
			if(ns <= 3)
			{
				fl = 0;
				break;
			}
			l1:int u1 = rand() % ns, v = rand() % ns, w = rand() % ns;
			if(u1 == v || u1 == w || v == w) goto l1;
			pt a = r[u1], b = r[v], c = r[w];
			pt o = cer(a, b, c);
			y[j].u = o, y[j].r = (o - a).len();
			db u2 = (o - b).len();
			if(y[j].r > 750000 || y[j].r < 250000)
			{
				fl = 0;
				break;
			}
		//	if(abs(u2 - y[j].r) > 100) cout<<"WA"<<endl;
			vector<pt> g;
			for(int m = 0; m < ns; m++)
				if(!check(y[j], r[m])) g.push_back(r[m]);
			r = g;
		}
		if(!fl) continue;
		int ns[5] = {0, 0, 0, 0, 0};
		cr z[5];
		for(int i = 0; i < 5; i++)
			z[i].u = pt(0, 0),
			z[i].r = 0;
		vector<pt> s[5];
		for(int j = 0; j < u.size(); j++)
		{
			int nmm = maxn, mpl = 0;
			for(int t = 1; t <= k; t++)
				if(check(y[t], u[j]))
					if(ns[t] < nmm)
						nmm = ns[t], mpl = t;
			ns[mpl]++;
			s[mpl].push_back(u[j]);
		}

		int dv = 0;
		for(int j = 1; j <= k; j++)
			dv += abs(ns[j] - n);
		//if(dv < 10)
		if(dv < mn)
		{
			for(int i = 1; i <= k; i++)
			{
				z[i].u = y[i].u;
				for(int t = 0; t < s[i].size(); t++)
					z[i].r += (z[i].u - s[i][t]).len();
				z[i].r /= ns[i];
			}
	//		cout<<"!!!"<<dv<<" "<<y[1].u.x<<" "<<y[1].u.y<<" "<<y[1].r<<endl;
		//	for(int j = 0; j < u.size(); j++)
	//			cout<<check(y[1], u[j])<<" ";
	//		cout<<endl;
			mn = dv;
			for(int j = 1; j <= k; j++)
				x[j] = z[j];
		}

	}

}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);

	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(s);
	for(int i = 1; i <= k; i++)
		printf("%.10lf %.10lf %.10lf\n", x[i].u.x, x[i].u.y, x[i].r);
//	return 0;
	return 0;
}

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		o.x += rand() % 20000, o.y += rand() % 20000;
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 6000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.8999, rs = 1.1001;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.5;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 11000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(3);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.1;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(tm & 1) o.x += rand(), o.y += rand();
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 12000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.898, rs = 1.102;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.5;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 230000 || r > 770000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 11000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(tm & 1) o.x += rand(), o.y += rand();
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 6000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.88, rs = 1.12;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = 0;
	int tm = 0;
	cr nu;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 248000 || r > 751000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(sm > mx)
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 11000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 4005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
int mn = maxn;
int n, k;
int fl[maxn];
bool check(cr a, pt b)
{
	db n1 = (a.u - b).len();
	return (n1 >= a.r * ls) && (n1 <= a.r * rs);
}
void cal(vector<pt> u)
{
	int lst = maxn;
	vector<pt> r;
	int tm = 0;
	while(1)
	{
		tm++;
		if(!(tm % 1000))
			if(clock() / CLOCKS_PER_SEC > 10) break;
		cr y[5];
		r = u;
		int fl = 1;
		for(int j = 1; j <= k; j++)
		{
			int ns = r.size();
			if(ns <= 3)
			{
				fl = 0;
				break;
			}
			l1:int u1 = rand() % ns, v = rand() % ns, w = rand() % ns;
			if(u1 == v || u1 == w || v == w) goto l1;
			pt a = r[u1], b = r[v], c = r[w];
			pt o = cer(a, b, c);
			y[j].u = o, y[j].r = (o - a).len();
			db u2 = (o - b).len();
			if(y[j].r > 750000 || y[j].r < 250000)
			{
				fl = 0;
				break;
			}
		//	if(abs(u2 - y[j].r) > 100) cout<<"WA"<<endl;
			vector<pt> g;
			for(int m = 0; m < ns; m++)
				if(!check(y[j], r[m])) g.push_back(r[m]);
			r = g;
		}
		if(!fl) continue;
		int ns[5] = {0, 0, 0, 0, 0};
		cr z[5];
		for(int i = 0; i < 5; i++)
			z[i].u = pt(0, 0),
			z[i].r = 0;
		vector<pt> s[5];
		for(int j = 0; j < u.size(); j++)
		{
			int nmm = maxn, mpl = 0;
			for(int t = 1; t <= k; t++)
				if(check(y[t], u[j]))
					if(ns[t] < nmm)
						nmm = ns[t], mpl = t;
			ns[mpl]++;
			z[mpl].u = z[mpl].u + u[j];
			s[mpl].push_back(u[j]);
		}

		int dv = 0;
		for(int j = 1; j <= k; j++)
			dv += abs(ns[j] - n);
		//if(dv < 10)
		if(dv < mn)
		{
			for(int i = 1; i <= k; i++)
			{
				z[i].u = z[i].u * (1.0 / ns[i]);
				for(int t = 0; t < s[i].size(); t++)
					z[i].r += (z[i].u - s[i][t]).len();
				z[i].r /= ns[i];
			}
	//		cout<<"!!!"<<dv<<" "<<y[1].u.x<<" "<<y[1].u.y<<" "<<y[1].r<<endl;
		//	for(int j = 0; j < u.size(); j++)
	//			cout<<check(y[1], u[j])<<" ";
	//		cout<<endl;
			mn = dv;
			for(int j = 1; j <= k; j++)
				x[j] = z[j];
		}

	}

}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);

	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(s);
	for(int i = 1; i <= k; i++)
		printf("%.10lf %.10lf %.10lf\n", x[i].u.x, x[i].u.y, x[i].r);
//	return 0;
	return 0;
}

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.8999, rs = 1.1001;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.5;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 248000 || r > 751000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 11000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(tm & 1) o.x += rand(), o.y += rand();
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 12000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.8999, rs = 1.1001;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = 0;
	int tm = 0;
	cr nu;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 248000 || r > 751000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(sm > mx)
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 10000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.8799, rs = 1.1299;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = 0;
	int tm = 0;
	cr nu;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 248000 || r > 751000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(sm > mx)
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 13000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 60000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 6000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 4005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
int mn = maxn;
int n, k;
int fl[maxn];
bool check(cr a, pt b)
{
	db n1 = (a.u - b).len();
	return (n1 >= a.r * ls) && (n1 <= a.r * rs);
}
void cal(vector<pt> u)
{
	int lst = maxn;
	vector<pt> r;
	int tm = 0;
	while(1)
	{
		tm++;
		if(!(tm % 1000))
			if(clock() / CLOCKS_PER_SEC > 13) break;
		cr y[5];
		r = u;
		int fl = 1;
		for(int j = 1; j <= k; j++)
		{
			int ns = r.size();
			if(ns <= 3)
			{
				fl = 0;
				break;
			}
			l1:int u1 = rand() % ns, v = rand() % ns, w = rand() % ns;
			if(u1 == v || u1 == w || v == w) goto l1;
			pt a = r[u1], b = r[v], c = r[w];
			pt o = cer(a, b, c);
			y[j].u = o, y[j].r = (o - a).len();
			db u2 = (o - b).len();
			if(y[j].r > 750000 || y[j].r < 250000)
			{
				fl = 0;
				break;
			}
		//	if(abs(u2 - y[j].r) > 100) cout<<"WA"<<endl;
			vector<pt> g;
			for(int m = 0; m < ns; m++)
				if(!check(y[j], r[m])) g.push_back(r[m]);
			r = g;
		}
		if(!fl) continue;
		int ns[5] = {0, 0, 0, 0, 0};
		cr z[5];
		for(int i = 0; i < 5; i++)
			z[i].u = pt(0, 0),
			z[i].r = 0;
		vector<pt> s[5];
		for(int j = 0; j < u.size(); j++)
		{
			int nmm = maxn, mpl = 0;
			for(int t = 1; t <= k; t++)
				if(check(y[t], u[j]))
					if(ns[t] < nmm)
						nmm = ns[t], mpl = t;
			ns[mpl]++;
			s[mpl].push_back(u[j]);
		}

		int dv = 0;
		for(int j = 1; j <= k; j++)
			dv += abs(ns[j] - n);
		//if(dv < 10)
		if(dv < mn)
		{
			for(int i = 1; i <= k; i++)
			{
				z[i].u = y[i].u;
				for(int t = 0; t < s[i].size(); t++)
					z[i].r += (z[i].u - s[i][t]).len();
				z[i].r /= ns[i];
			}
	//		cout<<"!!!"<<dv<<" "<<y[1].u.x<<" "<<y[1].u.y<<" "<<y[1].r<<endl;
		//	for(int j = 0; j < u.size(); j++)
	//			cout<<check(y[1], u[j])<<" ";
	//		cout<<endl;
			mn = dv;
			for(int j = 1; j <= k; j++)
				x[j] = z[j];
		}

	}

}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);

	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(s);
	for(int i = 1; i <= k; i++)
		printf("%.10lf %.10lf %.10lf\n", x[i].u.x, x[i].u.y, x[i].r);
//	return 0;
	return 0;
}

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.8999, rs = 1.1001;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.5;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 230000 || r > 770000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 11000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l3);
	db c2 = aco * aco * 2 - 1;
	return sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.9, rs = 1.1;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.5;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(o.len() > 1030000) continue;
		db r = (o - a).len();
		if(r < 230000 || r > 770000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(sm > mx)
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 11000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
#define maxn 1005
#define db double
using namespace std;
struct pt
{
	db x, y;
	pt(){x = 0, y = 0;}
	pt(db a, db b)
	{
		x = a, y = b;
	}
	db len()
	{
		return sqrt(x * x + y * y);
	}
	pt operator * (db u)
	{
		return pt(x * u, y * u);
	}
	pt operator + (pt u)
	{
		return pt(x + u.x, y + u.y);
	}
	pt operator - (pt u)
	{
		return pt(x - u.x, y - u.y);
	}
};
db cals(pt a, pt b, pt c)
{
	db l1 = (a - b).len(), l2 = (b - c).len(), l3 = (a - c).len();
	db aco = (l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2);
	db c2 = aco * aco * 2 - 1;
	int tp = 1;
	if(aco < 0) tp = -1;
	return tp * sqrt(1 - c2 * c2);
}
pt cer(pt a, pt b, pt c)
{
	db n2 = cals(a, b, c), n1 = cals(b, a, c), n3 = cals(a, c, b);
	pt fn = a * n1 + b * n2 + c * n3;
	fn = fn * (1 / (n1 + n2 + n3));
	return fn;
}
struct cr
{
	pt u;
	db r;
}x[5];
db ls = 0.899, rs = 1.101;
void cal(int k, vector<pt> u)
{
//	cout<<k<<endl;
	if(k == 0) return ;
	int ns = u.size();
	int mx = -maxn;
	int tm = 0;
	cr nu;
	int nd = (ns / k) * 1.3;
	while(1)
	{
		tm++;
		l1:int i = rand() % ns, j = rand() % ns, k = rand() % ns;
		if(i == j || j == k || i == k) goto l1;
		pt a = u[i], b = u[j], c = u[k];
		pt o = cer(a, b, c);
		if(tm & 1) o.x += rand(), o.y += rand();
		if(o.len() > 1000000) continue;
		db r = (o - a).len();
		if(r < 250000 || r > 750000) continue;
		int sm = 0;
		for(int i = 0; i < ns; i++)
		{
			db n1 = (u[i] - o).len();
			if(n1 >= ls * r && n1 <= rs * r)
				sm++;
		}
		if(abs(sm - nd) < abs(mx - nd))
			mx = sm, nu.u = o, nu.r = r;
		if(tm > 6000) break;
	}
	x[k] = nu;
	vector<pt> v;
	for(int i = 0; i < ns; i++)
	{
		db n1 = (u[i] - nu.u).len();
		if(n1 >= ls * nu.r && n1 <= rs * nu.r) continue;
		v.push_back(u[i]);
	}
	cal(k - 1, v);
}
int main()
{
//	freopen("input1-win.txt", "r", stdin);
	srand(5);
	int n, k;
	cin>>k>>n;
	vector<pt> s;
	for(int i = 1; i <= n * k; i++)
	{
		int x, y;
		cin>>x>>y;
		s.push_back(pt(x, y));
	}
	cal(k, s);
	for(int i = 1; i <= k; i++)
		cout<<x[i].u.x<<" "<<x[i].u.y<<" "<<x[i].r<<endl;
	return 0;
}
/*
3
1
0 2
2 0
0 0
*/

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    for (point_t& p : pts) cin >> p.x >> p.y;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return (int) 1e9;
        return abs(cnt - n);
    };
    vector<Circle> res;
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 100000) {
            int u = mrand() % n;
            int v = mrand() % n;
            int w = mrand() % n;
            if (3e5 < dist(pts[u], pts[v]) &&
                    3e5 < dist(pts[v], pts[w]) &&
                    3e5 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.9 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                res.pb(c);
                break;
            }
        }
        FORd(i, sz(pts), 0) {
            double d = dist(res.back().cen, pts[i]);
            if (abs(log(d) - log(res.back().rad)) < log(1.1)) {
                pts.erase(pts.begin() + i);
            }
        }
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    for (point_t& p : pts) cin >> p.x >> p.y;
    k++;
    FORd(i, n, 0) {
        pts.pb(pts[i] + point_t(500000, 500000));
    }
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return (int) 1e9;
        return abs(cnt - n);
    };
    vector<Circle> res;
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 100000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (3e5 < dist(pts[u], pts[v]) &&
                    3e5 < dist(pts[v], pts[w]) &&
                    3e5 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.9 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                res.pb(c);
                break;
            }
        }
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    point_t cen;
    for (point_t& p : pts) cin >> p.x >> p.y, cen = cen + p;
    cen = cen / n;
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 0.5 + point_t(500000, 500000));
    //}
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 2 + point_t(2 * 500000, 2 * 500000));
    //}
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return (int) 1e9;
        return abs(cnt - n);
    };
    vector<Circle> res;
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 100000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (3e5 < dist(pts[u], pts[v]) &&
                    3e5 < dist(pts[v], pts[w]) &&
                    3e5 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        point_t cen;
        double rad = 0;
        int cnt = 0;
        Circle tmp;
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.1 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                tmp = c;
                break;
            }
        }
        for (auto e : candidates) {
            Circle c = e.se;
            double d = dist(c.cen, tmp.cen);
            if (d < 1e4) {
                cen = cen + c.cen;
                rad += c.rad;
                cnt++;
            }
        }
        cen = cen / cnt;
        rad = rad / cnt;
        res.pb(Circle(cen, rad));
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    point_t cen;
    for (point_t& p : pts) cin >> p.x >> p.y, cen = cen + p;
    //cen = cen / n;
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 0.5 + point_t(500000, 500000));
    //}
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return (int) 1e9;
        return abs(cnt - n);
    };
    vector<Circle> res;
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 100000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (3e5 < dist(pts[u], pts[v]) &&
                    3e5 < dist(pts[v], pts[w]) &&
                    3e5 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        point_t cen;
        double rad = 0;
        int cnt = 0;
        Circle tmp;
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.5 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                tmp = c;
                break;
            }
        }
        for (auto e : candidates) {
            Circle c = e.se;
            double d = dist(c.cen, tmp.cen);
            if (d < 1e5) {
                cen = cen + c.cen;
                rad += c.rad;
                cnt++;
            }
        }
        cen = cen / cnt;
        rad = rad / cnt;
        res.pb(Circle(cen, rad));
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    for (point_t& p : pts) cin >> p.x >> p.y;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return (int) 1e9;
        return abs(cnt - n);
    };
    vector<Circle> res;
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 100000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (3e5 < dist(pts[u], pts[v]) &&
                    3e5 < dist(pts[v], pts[w]) &&
                    3e5 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.9 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                res.pb(c);
                break;
            }
        }
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    for (point_t& p : pts) cin >> p.x >> p.y;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(log(d) - log(c.rad)) < log(1.1)) {
                cnt++;
            }
        }
        if (!cnt) return 1e9;
        return abs(log(cnt) - log(n));
    };
    vector<pair<double, Circle>> candidates;
    FOR(it, 0, 1000) {
        int u = mrand() % n;
        int v = mrand() % n;
        int w = mrand() % n;
        if (3e5 < dist(pts[u], pts[v]) &&
                3e5 < dist(pts[v], pts[w]) &&
                3e5 < dist(pts[w], pts[u])) {
            Circle c = CircumCircle(pts[u], pts[v], pts[w]);
            candidates.pb(mp(calc(c), c));
        }
    }
    sort(all(candidates));
    vector<Circle> res;
    for (auto e : candidates) if (sz(res) < k) {
        Circle c = e.se;
        int found = 0;
        for (Circle cc : res) {
            double d = dist(c.cen, cc.cen);
            if (log(d) - log(600000) < log(0.9)) {
                found = 1;
                break;
            }
        }
        if (!found) {
            res.pb(c);
        }
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    for (point_t& p : pts) cin >> p.x >> p.y;
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(log(d) - log(c.rad)) < log(1.1)) {
                cnt++;
            }
        }
        if (!cnt) return 1e9;
        return abs(log(cnt) - log(n));
    };
    vector<Circle> res;
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 1000) {
            int u = mrand() % n;
            int v = mrand() % n;
            int w = mrand() % n;
            if (3e5 < dist(pts[u], pts[v]) &&
                    3e5 < dist(pts[v], pts[w]) &&
                    3e5 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (log(d) - log(600000) < log(0.9)) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                res.pb(c);
                break;
            }
        }
        FORd(i, sz(pts), 0) {
            double d = dist(res.back().cen, pts[i]);
            if (abs(log(d) - log(res.back().rad)) < log(1.1)) {
                pts.erase(pts.begin() + i);
            }
        }
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

#define ms(s, n) memset(s, n, sizeof(s))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORd(i, a, b) for (int i = (a) - 1; i >= (b); --i)
#define FORall(it, a) for (__typeof((a).begin()) it = (a).begin(); it != (a).end(); it++)
#define sz(a) int((a).size())
#define present(t, x) (t.find(x) != t.end())
#define all(a) (a).begin(), (a).end()
#define uni(a) (a).erase(unique(all(a)), (a).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define prec(n) fixed<<setprecision(n)
#define bit(n, i) (((n) >> (i)) & 1)
#define bitcount(n) __builtin_popcountll(n)
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pi;
typedef vector<int> vi;
typedef vector<pi> vii;
const int MOD = (int) 1e9 + 7;
const int FFTMOD = 119 << 23 | 1;
const int INF = (int) 1e9 + 23111992;
const ll LINF = (ll) 1e18 + 23111992;
const ld PI = acos((ld) -1);
const ld EPS = 1e-9;
inline ll gcd(ll a, ll b) {ll r; while (b) {r = a % b; a = b; b = r;} return a;}
inline ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
inline ll fpow(ll n, ll k, int p = MOD) {ll r = 1; for (; k; k >>= 1) {if (k & 1) r = r * n % p; n = n * n % p;} return r;}
template<class T> inline int chkmin(T& a, const T& val) {return val < a ? a = val, 1 : 0;}
template<class T> inline int chkmax(T& a, const T& val) {return a < val ? a = val, 1 : 0;}
inline ull isqrt(ull k) {ull r = sqrt(k) + 1; while (r * r > k) r--; return r;}
inline ll icbrt(ll k) {ll r = cbrt(k) + 1; while (r * r * r > k) r--; return r;}
inline void addmod(int& a, int val, int p = MOD) {if ((a = (a + val)) >= p) a -= p;}
inline void submod(int& a, int val, int p = MOD) {if ((a = (a - val)) < 0) a += p;}
inline int mult(int a, int b, int p = MOD) {return (ll) a * b % p;}
inline int inv(int a, int p = MOD) {return fpow(a, p - 2, p);}
inline int sign(ld x) {return x < -EPS ? -1 : x > +EPS;}
inline int sign(ld x, ld y) {return sign(x - y);}
mt19937 mt(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int mrand() {return abs((int) mt());}
#define db(x) cerr << "[" << #x << ": " << (x) << "] ";
#define endln cerr << "\n";

#define double double
#define EPS 1e-9
struct point_t {
    double x, y;
    point_t() : x(0), y(0) {}
    point_t(double x, double y) : x(x), y(y) {}
    point_t(const point_t& p) : x(p.x), y(p.y) {}
    int operator < (const point_t& rhs) const {return make_pair(y, x) < make_pair(rhs.y, rhs.x);}
    int operator == (const point_t& rhs) const {return make_pair(y, x) == make_pair(rhs.y, rhs.x);}
    point_t operator + (const point_t& p) const {return point_t(x + p.x, y + p.y);}
    point_t operator - (const point_t& p) const {return point_t(x - p.x, y - p.y);}
    point_t operator * (double c) const {return point_t(x * c, y * c);}
    point_t operator / (double c) const {return point_t(x / c, y / c);}
};
double cross(point_t p, point_t q) {return p.x * q.y - p.y * q.x;}
double area(point_t a, point_t b, point_t c) {return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;}
double area2(point_t a, point_t b, point_t c) {return cross(a, b) + cross(b, c) + cross(c, a);}
double dot(point_t p, point_t q) {return p.x * q.x + p.y * q.y;}
double dist(point_t p, point_t q) {return sqrt(dot(p - q, p - q));}
double dist2(point_t p, point_t q) {return dot(p - q, p - q);}
point_t RotateCCW90(point_t p) {return point_t(-p.y, p.x);}
point_t RotateCW90(point_t p) {return point_t(p.y, -p.x);}
point_t RotateCCW(point_t p, double t) {return point_t(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));}
int sign(double x) {return x < -EPS ? -1 : x > EPS;}
int sign(double x, double y) {return sign(x - y);}
ostream& operator << (ostream& os, const point_t& p) {
    os << "(" << p.x << "," << p.y << ")";
    return os;
}
point_t ProjectPointLine(point_t a, point_t b, point_t c) {
    return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(point_t a, point_t b, point_t c) {
    return dist(c, ProjectPointLine(a, b, c));
}
point_t ComputeLineIntersection(point_t a, point_t b, point_t c, point_t d) {
    b = b - a; d = c - d; c = c - a;
    return a + b * cross(c, d) / cross(b, d);
}
struct Line {
    point_t l, r;
    Line() {}
    Line(point_t l, point_t r) : l(l), r(r) {}
    Line(const Line& rhs) : l(rhs.l), r(rhs.r) {}
};
Line Bisector(point_t a, point_t b) {
    point_t c = (a + b) / 2;
    return Line(c, c + RotateCCW90(b - c));
}
struct Circle {
    point_t cen;
    double rad;
    Circle() : rad(0) {}
    Circle(point_t cen, double rad) : cen(cen), rad(rad) {}
    Circle(const Circle& rhs) : cen(rhs.cen), rad(rhs.rad) {}
    int operator < (const Circle& rhs) const {
        return rad < rhs.rad;
    }
};
Circle CircumCircle(point_t a, point_t b, point_t c) {
    if (sign(cross(a - c, b - c)) == 0) {
        Circle res = Circle((a + b) / 2, dist(a, b) / 2);
        res = max(res, Circle((b + c) / 2, dist(b, c) / 2));
        res = max(res, Circle((c + a) / 2, dist(c, a) / 2));
        return res;
    }
    Line ln1 = Bisector(a, b);
    Line ln2 = Bisector(b, c);
    point_t cen = ComputeLineIntersection(ln1.l, ln1.r, ln2.l, ln2.r);
    return Circle(cen, dist(cen, a));
}

void chemthan() {
    int k, n; cin >> k >> n;
    vector<point_t> pts(n * k);
    point_t cen;
    for (point_t& p : pts) cin >> p.x >> p.y, cen = cen + p;
    cen = cen / n;
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 0.5 + point_t(500000, 500000));
    //}
    //k++;
    //FORd(i, n, 0) {
    //    pts.pb(cen + (pts[i] - cen) * 2 + point_t(2 * 500000, 2 * 500000));
    //}
    auto calc = [&] (Circle c) {
        int cnt = 0;
        FOR(i, 0, n * k) {
            double d = dist(c.cen, pts[i]);
            if (abs(d - c.rad) < 5e4) {
                cnt++;
            }
        }
        if (!cnt) return (int) 1e9;
        return abs(cnt - n);
    };
    vector<Circle> res;
    FOR(it, 0, k) {
        vector<pair<double, Circle>> candidates;
        FOR(it, 0, 100000) {
            int u = mrand() % sz(pts);
            int v = mrand() % sz(pts);
            int w = mrand() % sz(pts);
            if (3e5 < dist(pts[u], pts[v]) &&
                    3e5 < dist(pts[v], pts[w]) &&
                    3e5 < dist(pts[w], pts[u])) {
                Circle c = CircumCircle(pts[u], pts[v], pts[w]);
                candidates.pb(mp(calc(c), c));
            }
        }
        sort(all(candidates));
        point_t cen;
        double rad = 0;
        int cnt = 0;
        Circle tmp;
        for (auto e : candidates) {
            Circle c = e.se;
            int found = 0;
            for (Circle cc : res) {
                double d = dist(c.cen, cc.cen);
                if (d < 0.1 * 600000) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                tmp = c;
                break;
            }
        }
        for (auto e : candidates) {
            Circle c = e.se;
            double d = dist(c.cen, tmp.cen);
            if (d < 1e1) {
                cen = cen + c.cen;
                rad += c.rad;
                cnt++;
            }
        }
        cen = cen / cnt;
        rad = rad / cnt;
        res.pb(Circle(cen, rad));
    }
    assert(sz(res) == k);
    for (Circle c : res) {
        cout << prec(9) << c.cen.x << " " << c.cen.y << " " << c.rad << "\n";
    }
}

int main(int argc, char* argv[]) {
    ios_base::sync_with_stdio(0), cin.tie(0);
    if (argc > 1) {
        assert(freopen(argv[1], "r", stdin));
    }
    if (argc > 2) {
        assert(freopen(argv[2], "wb", stdout));
    }
    chemthan();
    cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
    return 0;
}

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
mt19937 mt(736);

using point = pair<double, double>;
using ipoint = pair<int, int>;

ipoint operator-(ipoint a, ipoint b)
{
	return {a.first - b.first, a.second - b.second};
}

template<class T>
T dist(T d, T r1, T r2)
{
	auto ans = numeric_limits<T>::max();

	for (int a : {-1, 1})
		for (int b : {-1, 1})
			ans = min(ans, d + a * r1 + b * r2);

	return ans;
}

template<class T>
T sqr(T x)
{
	return x * x;
}

double len2(ipoint A)
{
	return sqr((ll) A.first) + sqr((ll) A.second);
}

point circumcircle(ipoint A, ipoint B, ipoint C)
{
	auto D = A.first * (B.second - (double) C.second) + B.first * (C.second - (double) A.second) +
	         C.first * (A.second - (double) B.second);
	D *= 2;

	double x = (len2(A) * (B.second - C.second) + (len2(B)) * (C.second - A.second) +
	            len2(C) * (A.second - B.second)) / D;
	double y = (len2(A) * (C.first - B.first) + len2(B) * (A.first - C.first) +
	            len2(C) * (B.first - A.first)) / D;

	ipoint U(x, y);

	if (max(abs(x), abs(y)) > 1e6 || len2(U) > 1e12)
		return {numeric_limits<int>::max(), numeric_limits<int>::max()};
	return U;
}

void solve(istream &cin = std::cin, ostream &cout = std::cout)
{
	int k, n;

	cin >> k >> n;

	vector<ipoint> pts(n * k);

	for (auto &it : pts)
		cin >> it.first >> it.second;

	shuffle(pts.begin(), pts.end(), mt);

	while (true)
	{
		vector<ipoint> bad = pts;
		vector<pair<ipoint, int>> centers;

		for (int i = 0; i < 1e3 && !bad.empty(); i++)
		{
			shuffle(bad.begin(), bad.end(), mt);

			if (bad.size() < 3)
			{
				// do something
				break;
			}
			else
			{
				auto cent = circumcircle(bad[0], bad[1], bad[2]);

				if (cent.first != numeric_limits<int>::max())
				{
					int r = (int) round(sqrt(len2(cent - bad[0])));
					int cnt = 0;

					r = min(r, 750000);
					r = max(r, 250000);

					for (auto it : pts)
						if (abs(sqrt(len2(cent - it)) - r) <= 0.1 * r + 90000)
							cnt++;

					if (cnt >= n)
					{
						if (centers.size() < k)
						{
							centers.emplace_back(cent, r);
						}
						else
						{
							vector<int> d(k);

							for (int j = 0; j < k; j++)
								d[j] = dist((int) sqrt(len2(centers[j].first - cent)), centers[j].second, r);

							int wh = min_element(d.begin(), d.end()) - d.begin();

							centers[wh].first.first = (centers[wh].first.first + cent.first) / 2;
							centers[wh].first.second = (centers[wh].first.second + cent.second) / 2;
							centers[wh].second = (centers[wh].second + r) / 2;
						}
					}
				}
			}

			bad.clear();

			for (auto it : pts)
			{
				bool good = false;

				for (auto cent : centers)
				{
					if (abs(sqrt(len2(cent.first - it)) - cent.second) <= 0.1 * cent.second + 90000)
					{
						good = true;
						break;
					}
				}

				if (!good)
					bad.push_back(it);
			}
		}

		if (bad.empty() && centers.size() == k)
		{
			for (auto it : centers)
				cout << it.first.first << ' ' << it.first.second << ' ' << it.second << endl;

			return;
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	cout << fixed;

#ifdef LOCAL
	ifstream fin("../input.txt");

	solve(fin);

	cout << setprecision(4);
	cout << "clock: " << clock() / (double) CLOCKS_PER_SEC << endl;
#else
	solve();
#endif

	return 0;
}

#include <bits/stdc++.h>

using namespace std;

using ll = long long;
mt19937 mt(736);

using point = pair<double, double>;
using ipoint = pair<int, int>;

const int miss = 50000;

ipoint operator-(ipoint a, ipoint b)
{
	return {a.first - b.first, a.second - b.second};
}

template<class T>
T dist(T d, T r1, T r2)
{
	auto ans = numeric_limits<T>::max();

	for (int a : {-1, 1})
		for (int b : {-1, 1})
			ans = min(ans, d + a * r1 + b * r2);

	return ans;
}

template<class T>
T sqr(T x)
{
	return x * x;
}

double len2(ipoint A)
{
	return sqr((ll) A.first) + sqr((ll) A.second);
}

point circumcircle(ipoint A, ipoint B, ipoint C)
{
	auto D = A.first * (B.second - (double) C.second) + B.first * (C.second - (double) A.second) +
	         C.first * (A.second - (double) B.second);
	D *= 2;

	double x = (len2(A) * (B.second - C.second) + (len2(B)) * (C.second - A.second) +
	            len2(C) * (A.second - B.second)) / D;
	double y = (len2(A) * (C.first - B.first) + len2(B) * (A.first - C.first) +
	            len2(C) * (B.first - A.first)) / D;

	ipoint U(x, y);

	if (max(abs(x), abs(y)) > 1e6 || len2(U) > 1e12)
		return {numeric_limits<int>::max(), numeric_limits<int>::max()};
	return U;
}

void solve(istream &cin = std::cin, ostream &cout = std::cout)
{
	int k, n;

	cin >> k >> n;

	vector<ipoint> pts(n * k);

	for (auto &it : pts)
		cin >> it.first >> it.second;

	shuffle(pts.begin(), pts.end(), mt);

	while (true)
	{
		vector<ipoint> bad = pts;
		vector<pair<ipoint, int>> centers;

		for (int i = 0; i < 1e3 && !bad.empty(); i++)
		{
			shuffle(bad.begin(), bad.end(), mt);

			if (bad.size() < 3)
			{
				// do something
				break;
			}
			else
			{
				auto cent = circumcircle(bad[0], bad[1], bad[2]);

				if (cent.first != numeric_limits<int>::max())
				{
					int r = (int) round(sqrt(len2(cent - bad[0])));
					int cnt = 0;

					r = min(r, 750000);
					r = max(r, 250000);

					for (auto it : pts)
						if (abs(sqrt(len2(cent - it)) - r) <= 0.1 * r + miss)
							cnt++;

					if (cnt >= n)
					{
						if (centers.size() < k)
						{
							centers.emplace_back(cent, r);
						}
						else
						{
							vector<int> d(k);

							for (int j = 0; j < k; j++)
								d[j] = dist((int) sqrt(len2(centers[j].first - cent)), centers[j].second, r);

							int wh = min_element(d.begin(), d.end()) - d.begin();

							centers[wh].first.first = (centers[wh].first.first + cent.first) / 2;
							centers[wh].first.second = (centers[wh].first.second + cent.second) / 2;
							centers[wh].second = (centers[wh].second + r) / 2;
						}
					}
				}
			}

			bad.clear();

			for (auto it : pts)
			{
				bool good = false;

				for (auto cent : centers)
				{
					if (abs(sqrt(len2(cent.first - it)) - cent.second) <= 0.1 * cent.second + miss)
					{
						good = true;
						break;
					}
				}

				if (!good)
					bad.push_back(it);
			}
		}

		if (bad.empty() && centers.size() == k)
		{
			for (auto it : centers)
				cout << it.first.first << ' ' << it.first.second << ' ' << it.second << endl;

			return;
		}
	}
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);

	cout << fixed;

#ifdef LOCAL
	ifstream fin("../input.txt");

	solve(fin);

	cout << setprecision(4);
	cout << "clock: " << clock() / (double) CLOCKS_PER_SEC << endl;
#else
	solve();
#endif

	return 0;
}

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;

#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
int gcd(int a,int b) { return b==0?a:gcd(b,a%b); }

const int MAXRING=4;
const int MAXEACH=1000;
const int MAXN=MAXRING*MAXEACH;
const double M_PI=acos(-1.0);
struct P { double x,y; P() {} P(double x,double y):x(x),y(y) {} };
struct Circle { P center; double r; Circle() {} Circle(P center,double r):center(center),r(r) {} };

double dist(const P &a,const P &b) { double dx=a.x-b.x,dy=a.y-b.y; return sqrt(dx*dx+dy*dy); }

int nring,neach,n;
P p[MAXN];

std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());

bool makecircle(const P &a,const P &b,const P &c,P &center,double &r) {
	double denx=2*(a.y*(c.x-b.x)+b.y*(a.x-c.x)+c.y*(b.x-a.x));
	double deny=2*(a.x*(c.y-b.y)+b.x*(a.y-c.y)+c.x*(b.y-a.y));
	if(fabs(denx)<1e-3||fabs(deny)<1e-3) return false;
	double cx2=c.x*c.x,bx2=b.x*b.x,cy2=c.y*c.y,by2=b.y*b.y,ax2=a.x*a.x,ay2=a.y*a.y;
	double numx=a.y*(cx2-bx2+cy2-by2)+b.y*(ax2-cx2+ay2-cy2)+c.y*(bx2-ax2+by2-ay2);
	double numy=a.x*(cx2-bx2+cy2-by2)+b.x*(ax2-cx2+ay2-cy2)+c.x*(bx2-ax2+by2-ay2);
	center=P(numx/denx,numy/deny); r=(dist(a,center)+dist(b,center)+dist(c,center))/3;
	return true;
}

vector<pair<Circle,double>> opt;

double dist(const Circle &a,const Circle &b) {
	double d=dist(a.center,b.center);
	vector<double> v(4); REP(i,4) { double cur=d; if((i&1)==0) cur+=a.r; else cur-=a.r; if((i&2)==0) cur+=b.r; else cur-=b.r; v[i]=abs(cur); }
	double ret=0; REP(i,4) REP(diff,2) { int j=i^(1<<diff); ret=max(ret,min(v[i],v[j])); } return ret;
}

void addopt(Circle c) {
	vector<double> cur;
	REP(j,n) {
		double me=fabs(dist(c.center,p[j])-c.r);
		bool ok=true; REPSZ(i,opt) if(dist(c,opt[i].first)>300000&&fabs(dist(opt[i].first.center,p[j])-opt[i].first.r)<me) { ok=false; break; }
		if(ok) cur.PB(me);
	}
	sort(cur.begin(),cur.end());
	int cnt=min(SZ(cur),neach);
	if(2*cnt<neach) return;
	//printf("adding -> cnt=%d (neach=%d)\n",cnt,neach);
	double sum=0; REP(j,cnt) sum+=cur[j]; sum/=cnt;
	vector<int> close;
	REPSZ(j,opt) {
		double cur=dist(c,opt[j].first);
		bool isclose=cur<300000;
		if(!isclose) continue;
		if(isclose&&sum>opt[j].second) return;
		close.PB(j);
	}
	if(SZ(close)>0) {
		REPSZ(i,close) opt.erase(opt.begin()+close[i]-i);
		opt.PB(MP(c,sum));
		//printf("replaced close\n");
	} else if(SZ(opt)<nring) {
		opt.PB(MP(c,sum));
		//printf("added\n");
	} else {
		int worst=-1; REPSZ(j,opt) if(worst==-1||opt[j].second>opt[worst].second) worst=j;
		if(sum>opt[worst].second) return;
		opt[worst]=MP(c,sum);
		//printf("replaced distant\n");
	}
}

void solve() {
	opt.clear();
	REP(i,10000) {
		int a=rnd()%n,b=rnd()%n,c=rnd()%n; if(b==a||c==a||c==b) continue;
		P center; double r; if(!makecircle(p[a],p[b],p[c],center,r)) continue;
		addopt(Circle(center,r));
		//printf("(%lf,%lf) rad=%lf sum=%lf\n",center.x,center.y,r,sum);
	}
	assert(SZ(opt)==nring);
}

void run() {
	scanf("%d%d",&nring,&neach); n=nring*neach;
	REP(i,n) scanf("%lf%lf",&p[i].x,&p[i].y);
	solve();
	REPSZ(i,opt) printf("%lf %lf %lf\n",opt[i].first.center.x,opt[i].first.center.y,opt[i].first.r);
}

void stress() {
	std::mt19937 genrnd(12312);
	const double omx=1000000;
	std::uniform_real_distribution<double> gensquare(-omx, omx);
	std::uniform_real_distribution<double> genradius(250000, 750000);
	std::uniform_real_distribution<double> genang(0, 2*M_PI);
	std::uniform_real_distribution<double> genmlt(0.9,1.1);
	int mxring=4;
	REP(rep,100) {
		nring=genrnd()%mxring+1;
		neach=genrnd()%(1000-100+1)+100;
		n=nring*neach;
		vector<Circle> c(nring);
		REP(i,nring) {
			while(true) {
				double cx=gensquare(genrnd),cy=gensquare(genrnd); if(cx*cx+cy*cy>omx*omx) continue;
				c[i].center=P(cx,cy);
				c[i].r=genradius(genrnd);
				//printf("testing (%lf,%lf,%lf)\n",c[i].center.x,c[i].center.y,c[i].r);
				bool ok=true; REP(j,i) if(dist(c[i],c[j])<600000) ok=false; if(!ok) continue;
				break;
			}

			REP(j,neach) {
				double ang=genang(genrnd),mlt=genmlt(genrnd);
				double x=floor(c[i].center.x+mlt*c[i].r*cos(ang)+.5),y=floor(c[i].center.y+mlt*c[i].r*sin(ang)+.5);
				p[i*neach+j]=P(x,y);
			}
		}
		shuffle(p,p+n,genrnd);
		if(rep!=1) continue;
		solve();
		vector<int> perm(nring); REP(i,nring) perm[i]=i;
		double best=1e200; vector<int> bestperm;
		do {
			double cur=0; REP(i,nring) cur=max(cur,dist(c[i],opt[perm[i]].first)); if(cur<best) best=cur,bestperm=perm;
		} while(next_permutation(perm.begin(),perm.end()));
		printf("want:"); REP(i,nring) printf(" (%.0lf,%.0lf,%.0lf)",c[i].center.x,c[i].center.y,c[i].r); puts("");
		printf("have:"); REP(i,nring) printf(" (%.0lf,%.0lf,%.0lf)",opt[bestperm[i]].first.center.x,opt[bestperm[i]].first.center.y,opt[bestperm[i]].first.r); puts("");
		printf("rep=%d best=%lf\n",rep,best);
		if(best>400000) return;

	}
}

int main() {
	run();
	//stress();
	return 0;
}

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;

#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
int gcd(int a,int b) { return b==0?a:gcd(b,a%b); }

const int MAXRING=4;
const int MAXEACH=1000;
const int MAXN=MAXRING*MAXEACH;
struct P { double x,y; P() {} P(double x,double y):x(x),y(y) {} };
struct Circle { P center; double r; Circle() {} Circle(P center,double r):center(center),r(r) {} };

double dist(const P &a,const P &b) { double dx=a.x-b.x,dy=a.y-b.y; return sqrt(dx*dx+dy*dy); }

int nring,neach,n;
P p[MAXN];

std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());

bool makecircle(const P &a,const P &b,const P &c,P &center,double &r) {
	double denx=2*(a.y*(c.x-b.x)+b.y*(a.x-c.x)+c.y*(b.x-a.x));
	double deny=2*(a.x*(c.y-b.y)+b.x*(a.y-c.y)+c.x*(b.y-a.y));
	if(fabs(denx)<1e-3||fabs(deny)<1e-3) return false;
	double cx2=c.x*c.x,bx2=b.x*b.x,cy2=c.y*c.y,by2=b.y*b.y,ax2=a.x*a.x,ay2=a.y*a.y;
	double numx=a.y*(cx2-bx2+cy2-by2)+b.y*(ax2-cx2+ay2-cy2)+c.y*(bx2-ax2+by2-ay2);
	double numy=a.x*(cx2-bx2+cy2-by2)+b.x*(ax2-cx2+ay2-cy2)+c.x*(bx2-ax2+by2-ay2);
	center=P(numx/denx,numy/deny); r=(dist(a,center)+dist(b,center)+dist(c,center))/3;
}

vector<pair<Circle,double>> opt;

double dist(const Circle &a,const Circle &b) {
	double d=dist(a.center,b.center);
	vector<double> v(4); REP(i,4) { double cur=d; if((i&1)==0) cur+=a.r; else cur-=a.r; if((i&2)==0) cur+=b.r; else cur-=b.r; v[i]=abs(cur); }
	double ret=0; REP(i,4) REP(diff,2) { int j=i^(1<<diff); ret=max(ret,min(v[i],v[j])); } return ret;
}

void addopt(Circle c) {
	vector<double> cur(n); REP(j,n) cur[j]=fabs(dist(c.center,p[j])-c.r); sort(cur.begin(),cur.end());
	double sum=0; REP(j,neach) sum+=cur[j];
	vector<int> close;
	REPSZ(j,opt) {
		double cur=dist(c,opt[j].first);
		bool isclose=cur<300000;
		if(!isclose) continue;
		if(isclose&&sum>opt[j].second) return;
		close.PB(j);
	}
	if(SZ(close)>0) {
		REPSZ(i,close) opt.erase(opt.begin()+close[i]-i);
		opt.PB(MP(c,sum));
		//printf("replaced close\n");
	} else if(SZ(opt)<nring) {
		opt.PB(MP(c,sum));
		//printf("added\n");
	} else {
		int worst=-1; REPSZ(j,opt) if(worst==-1||opt[j].second>opt[worst].second) worst=j;
		if(sum>opt[worst].second) return;
		opt[worst]=MP(c,sum);
		//printf("replaced distant\n");
	}
}

void solve() {
	opt.clear();
	REP(i,100000) {
		int a=rnd()%n,b=rnd()%n,c=rnd()%n; if(b==a||c==a||c==b) continue;
		P center; double r; if(!makecircle(p[a],p[b],p[c],center,r)) continue;
		addopt(Circle(center,r));
		//printf("(%lf,%lf) rad=%lf sum=%lf\n",center.x,center.y,r,sum);
	}
	assert(SZ(opt)==nring);
}

void run() {
	scanf("%d%d",&nring,&neach); n=nring*neach;
	REP(i,n) scanf("%lf%lf",&p[i].x,&p[i].y);
	solve();
	REPSZ(i,opt) printf("%lf %lf %lf\n",opt[i].first.center.x,opt[i].first.center.y,opt[i].first.r);
}

int main() {
	run();
	return 0;
}

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;

#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
int gcd(int a,int b) { return b==0?a:gcd(b,a%b); }

const int MAXRING=4;
const int MAXEACH=1000;
const int MAXN=MAXRING*MAXEACH;
struct P { double x,y; P() {} P(double x,double y):x(x),y(y) {} };
struct Circle { P center; double r; Circle() {} Circle(P center,double r):center(center),r(r) {} };

double dist(const P &a,const P &b) { double dx=a.x-b.x,dy=a.y-b.y; return sqrt(dx*dx+dy*dy); }

int nring,neach,n;
P p[MAXN];

std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());

bool makecircle(const P &a,const P &b,const P &c,P &center,double &r) {
	double denx=2*(a.y*(c.x-b.x)+b.y*(a.x-c.x)+c.y*(b.x-a.x));
	double deny=2*(a.x*(c.y-b.y)+b.x*(a.y-c.y)+c.x*(b.y-a.y));
	if(fabs(denx)<1e-3||fabs(deny)<1e-3) return false;
	double cx2=c.x*c.x,bx2=b.x*b.x,cy2=c.y*c.y,by2=b.y*b.y,ax2=a.x*a.x,ay2=a.y*a.y;
	double numx=a.y*(cx2-bx2+cy2-by2)+b.y*(ax2-cx2+ay2-cy2)+c.y*(bx2-ax2+by2-ay2);
	double numy=a.x*(cx2-bx2+cy2-by2)+b.x*(ax2-cx2+ay2-cy2)+c.x*(bx2-ax2+by2-ay2);
	center=P(numx/denx,numy/deny); r=(dist(a,center)+dist(b,center)+dist(c,center))/3;
}

vector<pair<Circle,double>> opt;

double dist(const Circle &a,const Circle &b) {
	double d=dist(a.center,b.center);
	vector<double> v(4); REP(i,4) { double cur=d; if((i&1)==0) cur+=a.r; else cur-=a.r; if((i&2)==0) cur+=b.r; else cur-=b.r; v[i]=abs(cur); }
	double ret=0; REP(i,4) REP(diff,2) { int j=i^(1<<diff); ret=max(ret,min(v[i],v[j])); } return ret;
}

void addopt(Circle c) {
	vector<double> cur(n); REP(j,n) cur[j]=fabs(dist(c.center,p[j])-c.r); sort(cur.begin(),cur.end());
	double sum=0; REP(j,neach) sum+=cur[j];
	vector<int> close;
	REPSZ(j,opt) {
		double cur=dist(c,opt[j].first);
		bool isclose=cur<300000;
		if(!isclose) continue;
		if(isclose&&sum>opt[j].second) return;
		close.PB(j);
	}
	if(SZ(close)>0) {
		REPSZ(i,close) opt.erase(opt.begin()+close[i]-i);
		opt.PB(MP(c,sum));
		//printf("replaced close\n");
	} else if(SZ(opt)<nring) {
		opt.PB(MP(c,sum));
		//printf("added\n");
	} else {
		int worst=-1; REPSZ(j,opt) if(worst==-1||opt[j].second>opt[worst].second) worst=j;
		if(sum>opt[worst].second) return;
		opt[worst]=MP(c,sum);
		//printf("replaced distant\n");
	}
}

void solve() {
	opt.clear();
	REP(i,10000) {
		int a=rnd()%n,b=rnd()%n,c=rnd()%n; if(b==a||c==a||c==b) continue;
		P center; double r; if(!makecircle(p[a],p[b],p[c],center,r)) continue;
		addopt(Circle(center,r));
		//printf("(%lf,%lf) rad=%lf sum=%lf\n",center.x,center.y,r,sum);
	}
	assert(SZ(opt)==nring);
}

void run() {
	scanf("%d%d",&nring,&neach); n=nring*neach;
	REP(i,n) scanf("%lf%lf",&p[i].x,&p[i].y);
	solve();
	REPSZ(i,opt) printf("%lf %lf %lf\n",opt[i].first.center.x,opt[i].first.center.y,opt[i].first.r);
}

int main() {
	run();
	return 0;
}

#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;

#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
typedef long long ll;
int gcd(int a,int b) { return b==0?a:gcd(b,a%b); }

const int MAXRING=4;
const int MAXEACH=1000;
const int MAXN=MAXRING*MAXEACH;
struct P { double x,y; P() {} P(double x,double y):x(x),y(y) {} };
struct Circle { P center; double r; Circle() {} Circle(P center,double r):center(center),r(r) {} };

double dist(const P &a,const P &b) { double dx=a.x-b.x,dy=a.y-b.y; return sqrt(dx*dx+dy*dy); }

int nring,neach,n;
P p[MAXN];

std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());

bool makecircle(const P &a,const P &b,const P &c,P &center,double &r) {
	double denx=2*(a.y*(c.x-b.x)+b.y*(a.x-c.x)+c.y*(b.x-a.x));
	double deny=2*(a.x*(c.y-b.y)+b.x*(a.y-c.y)+c.x*(b.y-a.y));
	if(fabs(denx)<1e-3||fabs(deny)<1e-3) return false;
	double cx2=c.x*c.x,bx2=b.x*b.x,cy2=c.y*c.y,by2=b.y*b.y,ax2=a.x*a.x,ay2=a.y*a.y;
	double numx=a.y*(cx2-bx2+cy2-by2)+b.y*(ax2-cx2+ay2-cy2)+c.y*(bx2-ax2+by2-ay2);
	double numy=a.x*(cx2-bx2+cy2-by2)+b.x*(ax2-cx2+ay2-cy2)+c.x*(bx2-ax2+by2-ay2);
	center=P(numx/denx,numy/deny); r=(dist(a,center)+dist(b,center)+dist(c,center))/3;
}

vector<pair<Circle,double>> opt;

double dist(const Circle &a,const Circle &b) {
	double d=dist(a.center,b.center);
	vector<double> v(4); REP(i,4) { double cur=d; if((i&1)==0) cur+=a.r; else cur-=a.r; if((i&2)==0) cur+=b.r; else cur-=b.r; v[i]=abs(cur); }
	double ret=0; REP(i,4) REP(diff,2) { int j=i^(1<<diff); ret=max(ret,min(v[i],v[j])); } return ret;
}

void addopt(Circle c) {
	vector<double> cur(n); REP(j,n) cur[j]=fabs(dist(c.center,p[j])-c.r); sort(cur.begin(),cur.end());
	double sum=0; REP(j,neach) sum+=cur[j];
	vector<int> close;
	REPSZ(j,opt) {
		double cur=dist(c,opt[j].first);
		bool isclose=cur<300000;
		if(!isclose) continue;
		if(isclose&&sum>opt[j].second) return;
		close.PB(j);
	}
	if(SZ(close)>0) {
		REPSZ(i,close) opt.erase(opt.begin()+close[i]-i);
		opt.PB(MP(c,sum));
		//printf("replaced close\n");
	} else if(SZ(opt)<nring) {
		opt.PB(MP(c,sum));
		//printf("added\n");
	} else {
		int worst=-1; REPSZ(j,opt) if(worst==-1||opt[j].second>opt[worst].second) worst=j;
		if(sum>opt[worst].second) return;
		opt[worst]=MP(c,sum);
		//printf("replaced distant\n");
	}
}

void solve() {
	opt.clear();
	REP(i,1000) {
		int a=rnd()%n,b=rnd()%n,c=rnd()%n; if(b==a||c==a||c==b) continue;
		P center; double r; if(!makecircle(p[a],p[b],p[c],center,r)) continue;
		addopt(Circle(center,r));
		//printf("(%lf,%lf) rad=%lf sum=%lf\n",center.x,center.y,r,sum);
	}
	assert(SZ(opt)==nring);
}

void run() {
	scanf("%d%d",&nring,&neach); n=nring*neach;
	REP(i,n) scanf("%lf%lf",&p[i].x,&p[i].y);
	solve();
	REPSZ(i,opt) printf("%lf %lf %lf\n",opt[i].first.center.x,opt[i].first.center.y,opt[i].first.r);
}

int main() {
	run();
	return 0;
}

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

struct point {
  double x, y;
  point() {}
  point(double x_, double y_) : x(x_),y(y_) {}
  double len() {
    return sqrt(x*x+y*y);
  }
};
point operator-(const point& a, const point& b) {
  return {a.x-b.x, a.y-b.y};
}
point operator+(const point& a, const point& b) {
  return {a.x+b.x, a.y+b.y};
}
double operator*(const point& a, const point& b) {
  return a.x*b.x+a.y*b.y;
}
double operator%(const point& a, const point& b) {
  return a.x*b.y-a.y*b.x;
}
point operator*(const point& a, double f) {
  return {a.x*f, a.y*f};
}

struct Circle {
  point p;
  double r;
};

mt19937_64 mrand(chrono::steady_clock::now().time_since_epoch().count());
#define random erghergh
double random() {
  return 1.*mrand()/mrand.max();
}

point sampleCenter() {
  double x, y;
  do {
    x = random()*2e6-1e6;
    y = random()*2e6-1e6;
  } while (x*x+y*y > 1e6*1e6);
  return {x,y};
}

double pi = 3.141592653589793;

vector<point> genPoints(int n, int k, vector<Circle>&ans) {
  ans.resize(k);
  int ok = 0;
  while (!ok) {
    ok = 1;
    for (int i = 0; i < k; i++) {
      ans[i].p = sampleCenter();
      for (int j = 0; j < i; j++) {
	if ((ans[i].p-ans[j].p).len() < 6e5) ok = 0;
      }
    }
  }
  vector<point> points;
  for (int i = 0; i < k; i++) {
    ans[i].r = random()*5e5+2.5e5;
    for (int j = 0; j < n; j++) {
      double theta = random()*pi*2;
      double r = (random()*0.2+0.9)*ans[i].r;
      points.push_back({cos(theta)*r+ans[i].p.x, sin(theta)*r+ans[i].p.y});
    }
  }
  //shuffle(points.begin(), points.end(), mrand());
  return points;
}

Circle findCircle(point a, point b, point c) {
  Circle r;
  r.p = (point(a.y-b.y,b.x-a.x)*((a-c)*(b-c)/((a-b)%(b-c)))+a+b)*0.5;
  r.r = (a-r.p).len();
  //cout << (a-r.p).len() << ' ' << (b-r.p).len() << ' ' << (c-r.p).len() << endl;
  return r;
}

Circle refineCircle1(Circle old, vector<point>&points, int plot = 0) {
  int n = points.size();
  vector<double> x, y, r;
  x.push_back(old.p.x);
  y.push_back(old.p.y);
  r.push_back(old.r);
  for (int it = 0; it < 100; it++) {
    int ai = mrand()%n;
    int bi = mrand()%n;
    int ci = mrand()%n;
    Circle c = findCircle(points[ai], points[bi], points[ci]);
    if (c.r > old.r*0.9 && c.r < old.r*1.1) {
      x.push_back(c.p.x);
      y.push_back(c.p.y);
      r.push_back(c.r);
    }
  }
  if (plot) {
    for (int i = 0; i < x.size(); i++) {
      cerr << x[i] << ' ' << y[i] << endl;
    }
  }
  sort(x.begin(), x.end());
  sort(y.begin(), y.end());
  sort(r.begin(), r.end());
  int k = x.size()/2;
  return {{x[k], y[k]}, r[k]};
}

Circle refineCircle(Circle old, vector<point>&points, int plot = 0) {
  int n = points.size();
  const int sections = 8;

  for (int it = 0; it < 100; it++) {
    vector<double> r;
    r.push_back(old.r);
    for (point p : points) {
      double rr = (p-old.p).len();
      if (rr > old.r*0.8 && rr < old.r*1.2)
	r.push_back(rr);
    }
    sort(r.begin(), r.end());
    old.r = r[r.size()/2];

    if (plot) {
      cerr << old.p.x << ' ' << old.p.y << endl;
    }

    vector<int> section(sections, 0);
    vector<point> pos(sections, {0,0});
    for (point p : points) {
      int i = sections*(atan2(p.y-old.p.y,p.x-old.p.x)+pi)/(2*pi);
      assert(i >= 0 && i < sections);
      point f = p-old.p;
      double r = f.len();
      if (r > old.r*0.8 && r < old.r*1.2) {
	f = f*((r > old.r ? 1. : -1)/r);
	pos[i] = (pos[i]*section[i]+f)*(1./(section[i]+1));
	section[i]++;
      }
    }
    point dp(0,0);
    for (int i = 0; i < sections; i++) {
      dp = dp+pos[i]*1e4;
      continue;
      double a = (i+0.5)/sections*2*pi-pi;
      point p = point(cos(a),sin(a))*old.r+old.p;
      //cout << sections*(atan2(p.y-old.p.y,p.x-old.p.x)+pi)/(2*pi)-i-0.5 << endl;
      if (section[i] == 0) {
	section[i]++;
	pos[i] = pos[i]+p;
      }
      /*if (plot) {
	cerr << p.x << ' ' << p.y << endl;
	}*/
    }
    if (dp.len() < 1e3) break;
    old.p = old.p+dp;
  }
  return old;
}

double scoreCircle2(Circle c, vector<point>&points, double tol) {
  int count = 0;
  vector<double> ang;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      count++;
      ang.push_back(atan2(d.y,d.x));
    }
  }
  ang.push_back(-pi);
  ang.push_back(pi);
  sort(ang.begin(), ang.end());
  double last = ang[0];
  double maxgap = 0;
  for (double d : ang) {
    maxgap = max(maxgap, d-last);
    last = d;
  }
  return maxgap;
}

int found[22][12];
int nx = 20, ny;

double scoreCircle(Circle c, vector<point>&points, double tol, int plot = 0) {
  for (int i = 0; i < nx; i++)
    for (int j = 0; j < ny; j++)
      found[i][j] = 0;

  int score = 0;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    int x = nx*(atan2(d.y,d.x)+pi)/(2*pi);
    assert(x >= 0 && x < nx);
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      int y = (r-(1-tol))/(tol*2)*ny;
      assert(y >= 0 && y < ny);
      score += !(found[x][y]++);
    }
  }
  if (plot) {
    for (int x = 0; x < nx; x++) {
      for (int y = 0; y < ny; y++) {
	if (found[x][y]) {
	  double a = (x+0.5)/nx*2*pi-pi;
	  double r = c.r*((y+0.5)/ny*(2*tol)+(1-tol));
	  point p = point(cos(a),sin(a))*r+c.p;
	  cerr << p.x << ' ' << p.y << endl;
	}
      }
    }
  }
  return -score;
}

vector<point> filterCircle(Circle c, vector<point>&points, double tol) {
  vector<point> goods;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      goods.push_back(points[i]);
    }
  }
  return goods;
}

int main() {
  ios::sync_with_stdio(0); cin.tie(0);
  for (int trials = 0; trials < 10000*0+1; trials++) {
    //cout << trials << endl;
    int n = mrand()%901+100, k = mrand()%4+1;
    cin >> k >> n;

    ny = 2;
    vector<Circle> truth;
    vector<point> points(n*k);// = genPoints(n, k, truth);
    for (int i = 0; i < n*k; i++) {
      cin >> points[i].x >> points[i].y;
    }
    vector<pair<double,Circle>> cands;
    for (int it = 0; it < 10000; it++) {
      int ai = mrand()%(n*k);
      int bi = mrand()%(n*k);
      int ci = mrand()%(n*k);
      if (set<int>({ai,bi,ci}).size() < 3) continue;
      Circle c = findCircle(points[ai], points[bi], points[ci]);
      if (c.r > 7.5e5 || c.r < 2.5e5) continue;

      //vector<point> goods = filterCircle(p, a);
      //c = refineCircle(c, goods);
      //auto pb = scoreCircle(c, points, 0.1);
      double maxgap = scoreCircle(c, points, 0.1);
      //if (pb.second.size() >= n*0.9)
      cands.push_back({-maxgap,c});
      //cerr << c.p.x << ' ' << c.p.y << endl;
    }
    sort(cands.begin(), cands.end(), [](pair<double,Circle> a, pair<double,Circle> b) {return a.first > b.first;});
    vector<Circle> ans;
    for (auto pa : cands) {
      Circle a = pa.second;
      int ok = 1;
      for (Circle b : ans) {
	if ((a.p-b.p).len() < 5.5e5) ok = 0;
      }
      if (ok == 1) {
	ans.push_back(a);
	if ((int)ans.size() == k) break;
      }
    }
    if ((int)ans.size() < k) {
      cout << "Only found " << ans.size() << " circles" << endl;
      return 0;
    }

    vector<Circle> backup = ans;
    for (Circle&c : ans) {
      auto goods = filterCircle(c, points, 0.2);
      c = refineCircle(c, goods);
    }

    cout << setprecision(20);
    for (Circle c : ans) {
      cout << c.p.x << ' ' << c.p.y << ' ' << c.r << endl;
    }

    if (0) {
      int ok = 0;
      for (int i = 0; i < k; i++) {
	double min_dist = 1e9;
	double mini = -1;
	for (int j = 0; j < k; j++) {
	  double d = (truth[i].p-ans[j].p).len();
	  double r1 = truth[i].r, r2 = ans[j].r;
	  double dpp = abs(d+r1+r2);
	  double dpm = abs(d+r1-r2);
	  double dmp = abs(d-r1+r2);
	  double dmm = abs(d-r1-r2);
	  double haus = max({
	      min(dmm,dmp),
		min(dpm,dpp),
		min(dmm,dpm),
		min(dmp,dpp)});
	  if (haus < min_dist) {
	    min_dist = haus;
	    mini = j;
	  }
	}
	if (min_dist > 1e5) {
	  cout << min_dist/1e5 << endl;
	  cout << scoreCircle(truth[i], points, 0.1) << ' ' << scoreCircle(backup[mini], points, 0.1) << ' ' << scoreCircle(ans[mini], points, 0.1) << endl;
	} else ok++;
      }
      if (ok != k) {
	cout << "Failed" << endl;
	for (point p : points) {
	  cerr << p.x << ' ' << p.y << endl;
	}
	cerr << endl << endl;
	for (Circle c : ans) {
	  cout << "Score: " << scoreCircle(c, points, 0.1, 1) << endl;
	  auto goods = filterCircle(c, points, 0.2);
	  refineCircle(c, goods, 1);
	  cerr << c.p.x << ' ' << c.p.y << ' ' << endl;
	  for (int i = 0; i < 100; i++) {
	    double a = i*pi*2/100;
	    cerr << c.p.x+c.r*cos(a) << ' ' << c.p.y+c.r*sin(a) << endl;
	  }
	}
	cerr << endl << endl;
	for (Circle c : truth) {
	  cout << "Score: " << scoreCircle(c, points, 0.1) << endl;
	  cerr << c.p.x << ' ' << c.p.y << ' ' << endl;
	}
	return 0;
      }
    }
  }
}

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

struct point {
  double x, y;
  point() {}
  point(double x_, double y_) : x(x_),y(y_) {}
  double len() {
    return sqrt(x*x+y*y);
  }
};
point operator-(const point& a, const point& b) {
  return {a.x-b.x, a.y-b.y};
}
point operator+(const point& a, const point& b) {
  return {a.x+b.x, a.y+b.y};
}
double operator*(const point& a, const point& b) {
  return a.x*b.x+a.y*b.y;
}
double operator%(const point& a, const point& b) {
  return a.x*b.y-a.y*b.x;
}
point operator*(const point& a, double f) {
  return {a.x*f, a.y*f};
}

struct Circle {
  point p;
  double r;
};

mt19937_64 mrand(chrono::steady_clock::now().time_since_epoch().count());
#define random erghergh
double random() {
  return 1.*mrand()/mrand.max();
}

point sampleCenter() {
  double x, y;
  do {
    x = random()*2e6-1e6;
    y = random()*2e6-1e6;
  } while (x*x+y*y > 1e6*1e6);
  return {x,y};
}

double pi = 3.141592653589793;

vector<point> genPoints(int n, int k, vector<Circle>&ans) {
  ans.resize(k);
  int ok = 0;
  while (!ok) {
    ok = 1;
    for (int i = 0; i < k; i++) {
      ans[i].p = sampleCenter();
      for (int j = 0; j < i; j++) {
	if ((ans[i].p-ans[j].p).len() < 6e5) ok = 0;
      }
    }
  }
  vector<point> points;
  for (int i = 0; i < k; i++) {
    ans[i].r = random()*5e5+2.5e5;
    for (int j = 0; j < n; j++) {
      double theta = random()*pi*2;
      double r = (random()*0.2+0.9)*ans[i].r;
      points.push_back({cos(theta)*r+ans[i].p.x, sin(theta)*r+ans[i].p.y});
    }
  }
  //shuffle(points.begin(), points.end(), mrand());
  return points;
}

Circle findCircle(point a, point b, point c) {
  Circle r;
  r.p = (point(a.y-b.y,b.x-a.x)*((a-c)*(b-c)/((a-b)%(b-c)))+a+b)*0.5;
  r.r = (a-r.p).len();
  //cout << (a-r.p).len() << ' ' << (b-r.p).len() << ' ' << (c-r.p).len() << endl;
  return r;
}

Circle refineCircle1(Circle old, vector<point>&points, int plot = 0) {
  int n = points.size();
  vector<double> x, y, r;
  x.push_back(old.p.x);
  y.push_back(old.p.y);
  r.push_back(old.r);
  for (int it = 0; it < 100; it++) {
    int ai = mrand()%n;
    int bi = mrand()%n;
    int ci = mrand()%n;
    Circle c = findCircle(points[ai], points[bi], points[ci]);
    if (c.r > old.r*0.9 && c.r < old.r*1.1) {
      x.push_back(c.p.x);
      y.push_back(c.p.y);
      r.push_back(c.r);
    }
  }
  if (plot) {
    for (int i = 0; i < x.size(); i++) {
      cerr << x[i] << ' ' << y[i] << endl;
    }
  }
  sort(x.begin(), x.end());
  sort(y.begin(), y.end());
  sort(r.begin(), r.end());
  int k = x.size()/2;
  return {{x[k], y[k]}, r[k]};
}

Circle refineCircle(Circle old, vector<point>&points, int plot = 0) {
  int n = points.size();
  const int sections = 8;

  for (int it = 0; it < 100; it++) {
    vector<double> r;
    r.push_back(old.r);
    for (point p : points) {
      double rr = (p-old.p).len();
      if (rr > old.r*0.8 && rr < old.r*1.2)
	r.push_back(rr);
    }
    sort(r.begin(), r.end());
    old.r = r[r.size()/2];

    if (plot) {
      cerr << old.p.x << ' ' << old.p.y << endl;
    }

    vector<int> section(sections, 0);
    vector<point> pos(sections, {0,0});
    for (point p : points) {
      int i = sections*(atan2(p.y-old.p.y,p.x-old.p.x)+pi)/(2*pi);
      assert(i >= 0 && i < sections);
      point f = p-old.p;
      double r = f.len();
      if (r > old.r*0.8 && r < old.r*1.2) {
	f = f*((r > old.r ? 1. : -1)/r);
	pos[i] = (pos[i]*section[i]+f)*(1./(section[i]+1));
	section[i]++;
      }
    }
    point dp(0,0);
    for (int i = 0; i < sections; i++) {
      dp = dp+pos[i]*1e4;
      continue;
      double a = (i+0.5)/sections*2*pi-pi;
      point p = point(cos(a),sin(a))*old.r+old.p;
      //cout << sections*(atan2(p.y-old.p.y,p.x-old.p.x)+pi)/(2*pi)-i-0.5 << endl;
      if (section[i] == 0) {
	section[i]++;
	pos[i] = pos[i]+p;
      }
      /*if (plot) {
	cerr << p.x << ' ' << p.y << endl;
	}*/
    }
    if (dp.len() < 1e3) break;
    old.p = old.p+dp;
  }
  return old;
}

double scoreCircle2(Circle c, vector<point>&points, double tol) {
  int count = 0;
  vector<double> ang;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      count++;
      ang.push_back(atan2(d.y,d.x));
    }
  }
  ang.push_back(-pi);
  ang.push_back(pi);
  sort(ang.begin(), ang.end());
  double last = ang[0];
  double maxgap = 0;
  for (double d : ang) {
    maxgap = max(maxgap, d-last);
    last = d;
  }
  return maxgap;
}

int found[22][12];
int nx = 20, ny;

double scoreCircle(Circle c, vector<point>&points, double tol, int plot = 0) {
  for (int i = 0; i < nx; i++)
    for (int j = 0; j < ny; j++)
      found[i][j] = 0;

  int score = 0;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    int x = nx*(atan2(d.y,d.x)+pi)/(2*pi);
    assert(x >= 0 && x < nx);
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      int y = (r-(1-tol))/(tol*2)*ny;
      assert(y >= 0 && y < ny);
      score += !(found[x][y]++);
    }
  }
  if (plot) {
    for (int x = 0; x < nx; x++) {
      for (int y = 0; y < ny; y++) {
	if (found[x][y]) {
	  double a = (x+0.5)/nx*2*pi-pi;
	  double r = c.r*((y+0.5)/ny*(2*tol)+(1-tol));
	  point p = point(cos(a),sin(a))*r+c.p;
	  cerr << p.x << ' ' << p.y << endl;
	}
      }
    }
  }
  return -score;
}

vector<point> filterCircle(Circle c, vector<point>&points, double tol) {
  vector<point> goods;
  for (int i = 0; i < points.size(); i++) {
    point d = points[i]-c.p;
    double r = d.len()/c.r;
    if (r > 1-tol && r < 1+tol) {
      goods.push_back(points[i]);
    }
  }
  return goods;
}

int main() {
  ios::sync_with_stdio(0); cin.tie(0);
  for (int trials = 0; trials < 10000*0+1; trials++) {
    //cout << trials << endl;
    int n = mrand()%901+100, k = mrand()%4+1;
    cin >> k >> n;

    ny = 3;
    vector<Circle> truth;
    vector<point> points(n*k);// = genPoints(n, k, truth);
    for (int i = 0; i < n*k; i++) {
      cin >> points[i].x >> points[i].y;
    }
    vector<pair<double,Circle>> cands;
    for (int it = 0; it < 10000; it++) {
      int ai = mrand()%(n*k);
      int bi = mrand()%(n*k);
      int ci = mrand()%(n*k);
      if (set<int>({ai,bi,ci}).size() < 3) continue;
      Circle c = findCircle(points[ai], points[bi], points[ci]);
      if (c.r > 7.5e5 || c.r < 2.5e5) continue;

      //vector<point> goods = filterCircle(p, a);
      //c = refineCircle(c, goods);
      //auto pb = scoreCircle(c, points, 0.1);
      double maxgap = scoreCircle(c, points, 0.1);
      //if (pb.second.size() >= n*0.9)
      cands.push_back({-maxgap,c});
      //cerr << c.p.x << ' ' << c.p.y << endl;
    }
    sort(cands.begin(), cands.end(), [](pair<double,Circle> a, pair<double,Circle> b) {return a.first > b.first;});
    vector<Circle> ans;
    for (auto pa : cands) {
      Circle a = pa.second;
      int ok = 1;
      for (Circle b : ans) {
	if ((a.p-b.p).len() < 5.5e5) ok = 0;
      }
      if (ok == 1) {
	ans.push_back(a);
	if ((int)ans.size() == k) break;
      }
    }
    if ((int)ans.size() < k) {
      cout << "Only found " << ans.size() << " circles" << endl;
      return 0;
    }

    vector<Circle> backup = ans;
    for (Circle&c : ans) {
      auto goods = filterCircle(c, points, 0.2);
      c = refineCircle(c, goods);
    }

    cout << setprecision(20);
    for (Circle c : ans) {
      cout << c.p.x << ' ' << c.p.y << ' ' << c.r << endl;
    }

    if (0) {
      int ok = 0;
      for (int i = 0; i < k; i++) {
	double min_dist = 1e9;
	double mini = -1;
	for (int j = 0; j < k; j++) {
	  double d = (truth[i].p-ans[j].p).len();
	  double r1 = truth[i].r, r2 = ans[j].r;
	  double dpp = abs(d+r1+r2);
	  double dpm = abs(d+r1-r2);
	  double dmp = abs(d-r1+r2);
	  double dmm = abs(d-r1-r2);
	  double haus = max({
	      min(dmm,dmp),
		min(dpm,dpp),
		min(dmm,dpm),
		min(dmp,dpp)});
	  if (haus < min_dist) {
	    min_dist = haus;
	    mini = j;
	  }
	}
	if (min_dist > 1e5) {
	  cout << min_dist/1e5 << endl;
	  cout << scoreCircle(truth[i], points, 0.1) << ' ' << scoreCircle(backup[mini], points, 0.1) << ' ' << scoreCircle(ans[mini], points, 0.1) << endl;
	} else ok++;
      }
      if (ok != k) {
	cout << "Failed" << endl;
	for (point p : points) {
	  cerr << p.x << ' ' << p.y << endl;
	}
	cerr << endl << endl;
	for (Circle c : ans) {
	  cout << "Score: " << scoreCircle(c, points, 0.1, 1) << endl;
	  auto goods = filterCircle(c, points, 0.2);
	  refineCircle(c, goods, 1);
	  cerr << c.p.x << ' ' << c.p.y << ' ' << endl;
	  for (int i = 0; i < 100; i++) {
	    double a = i*pi*2/100;
	    cerr << c.p.x+c.r*cos(a) << ' ' << c.p.y+c.r*sin(a) << endl;
	  }
	}
	cerr << endl << endl;
	for (Circle c : truth) {
	  cout << "Score: " << scoreCircle(c, points, 0.1) << endl;
	  cerr << c.p.x << ' ' << c.p.y << ' ' << endl;
	}
	return 0;
      }
    }
  }
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.2;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	srand(69);
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}

	vector <pair<pdd,ld>> kan;

	for (int h=0; h<70000; h++)
	{
		int ile=los(2, 4);
		vector <pdd> daj;
		for (int i=0; i<ile; i++)
			daj.push_back(znam[los(0, m-1)]);
		pdd x=sr(daj);
		ld y=0;
		for (pdd j : daj)
			y+=odl(j, x);
		y/=ile;
		kan.push_back({x, y});
	}
	for (int h=0; h<k; h++)
	{
		int kto=-1;
		ld dokl=1e18;
		for (int i=0; i<(int)kan.size(); i++)
		{
			vector <ld> dys;
			for (int j=0; j<m; j++)
				dys.push_back(abs(kan[i].second-odl(kan[i].first, znam[j])));
			sort(dys.begin(), dys.end());
			ld x=dys[n-1];
			if (x<dokl)
			{
				dokl=x;
				kto=i;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		vector <pair<ld,pdd>>dys;
		for (int j=0; j<m; j++)
			dys.push_back({abs(kan[kto].second-odl(kan[kto].first, znam[j])), znam[j]});
		sort(dys.begin(), dys.end());
		znam.clear();
		for (int j=n; j<m; j++)
			znam.push_back(dys[j].second);
		m-=n;
		//~ ld x=dys[n-1];
		//~ if (x<dokl)
		//~ {
			//~ dokl=x;
			//~ kto=i;
		//~ }
		//~ for (int j=0; j<m; j++)
		//~ {
			//~ if (zawie(kan[kto], znam[j]))
			//~ {
				//~ m--;
				//~ swap(znam[j], znam[m]);
				//~ znam.pop_back();
				//~ j--;
			//~ }
		//~ }
	}
	return 0;
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.2;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	srand(time(0));
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}

	for (int h=0; h<k; h++)
	{
		vector <pair<pdd,ld>> kan;
		for (int h=0; h<100000; h++)
		{
			int ile=los(2, 5);
			vector <pdd> daj;
			for (int i=0; i<ile; i++)
				daj.push_back(znam[los(0, m-1)]);
			pdd x=sr(daj);
			ld y=0;
			for (pdd j : daj)
				y+=odl(j, x);
			y/=ile;
			kan.push_back({x, y});
		}
		int kto=-1;
		ld dokl=1e18;
		for (int i=0; i<(int)kan.size(); i++)
		{
			vector <ld> dys;
			for (int j=0; j<m; j++)
				dys.push_back(abs(kan[i].second-odl(kan[i].first, znam[j])));
			sort(dys.begin(), dys.end());
			ld x=dys[n-1];
			if (x<dokl)
			{
				dokl=x;
				kto=i;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		vector <pair<ld,pdd>>dys;
		for (int j=0; j<m; j++)
			dys.push_back({abs(kan[kto].second-odl(kan[kto].first, znam[j])), znam[j]});
		sort(dys.begin(), dys.end());
		znam.clear();
		for (int j=n; j<m; j++)
			znam.push_back(dys[j].second);
		m-=n;
		//~ ld x=dys[n-1];
		//~ if (x<dokl)
		//~ {
			//~ dokl=x;
			//~ kto=i;
		//~ }
		//~ for (int j=0; j<m; j++)
		//~ {
			//~ if (zawie(kan[kto], znam[j]))
			//~ {
				//~ m--;
				//~ swap(znam[j], znam[m]);
				//~ znam.pop_back();
				//~ j--;
			//~ }
		//~ }
	}
	return 0;
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.2;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	srand(69);
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}

	vector <pair<pdd,ld>> kan;

	for (int h=0; h<170000; h++)
	{
		int ile=los(2, 5);
		vector <pdd> daj;
		for (int i=0; i<ile; i++)
			daj.push_back(znam[los(0, m-1)]);
		pdd x=sr(daj);
		ld y=0;
		for (pdd j : daj)
			y+=odl(j, x);
		y/=ile;
		kan.push_back({x, y});
	}
	for (int h=0; h<k; h++)
	{
		int kto=-1;
		ld dokl=1e18;
		for (int i=0; i<(int)kan.size(); i++)
		{
			vector <ld> dys;
			for (int j=0; j<m; j++)
				dys.push_back(abs(kan[i].second-odl(kan[i].first, znam[j])));
			sort(dys.begin(), dys.end());
			ld x=dys[n-1];
			if (x<dokl)
			{
				dokl=x;
				kto=i;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		vector <pair<ld,pdd>>dys;
		for (int j=0; j<m; j++)
			dys.push_back({abs(kan[kto].second-odl(kan[kto].first, znam[j])), znam[j]});
		sort(dys.begin(), dys.end());
		znam.clear();
		for (int j=n; j<m; j++)
			znam.push_back(dys[j].second);
		m-=n;
		//~ ld x=dys[n-1];
		//~ if (x<dokl)
		//~ {
			//~ dokl=x;
			//~ kto=i;
		//~ }
		//~ for (int j=0; j<m; j++)
		//~ {
			//~ if (zawie(kan[kto], znam[j]))
			//~ {
				//~ m--;
				//~ swap(znam[j], znam[m]);
				//~ znam.pop_back();
				//~ j--;
			//~ }
		//~ }
	}
	return 0;
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.15;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}

	vector <pair<pdd,ld>> kan;

	for (int h=0; h<1000; h++)
	{
		int ile=los(3, 5);
		vector <pdd> daj;
		for (int i=0; i<ile; i++)
			daj.push_back(znam[los(0, m-1)]);
		pdd x=sr(daj);
		ld y=0;
		for (pdd j : daj)
			y+=odl(j, x);
		y/=ile;
		kan.push_back({x, y});
	}
	for (int h=0; h<k; h++)
	{
		int ile=-1;
		int kto=-1;
		for (int i=0; i<(int)kan.size(); i++)
		{
			int x=0;
			for (int j=0; j<m; j++)
				x+=zawie(kan[i], znam[j]);
			if (x>ile)
			{
				ile=x;
				kto=i;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		for (int j=0; j<m; j++)
		{
			if (zawie(kan[kto], znam[j]))
			{
				m--;
				swap(znam[j], znam[m]);
				znam.pop_back();
				j--;
			}
		}
	}
	return 0;
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.2;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}

	vector <pair<pdd,ld>> kan;

	for (int h=0; h<10000; h++)
	{
		int ile=los(2, 4);
		vector <pdd> daj;
		for (int i=0; i<ile; i++)
			daj.push_back(znam[los(0, m-1)]);
		pdd x=sr(daj);
		ld y=0;
		for (pdd j : daj)
			y+=odl(j, x);
		y/=ile;
		kan.push_back({x, y});
	}
	for (int h=0; h<k; h++)
	{
		int kto=-1;
		ld dokl=1e18;
		for (int i=0; i<(int)kan.size(); i++)
		{
			vector <ld> dys;
			for (int j=0; j<m; j++)
				dys.push_back(abs(kan[i].second-odl(kan[i].first, znam[j])));
			sort(dys.begin(), dys.end());
			ld x=dys[n-1];
			if (x<dokl)
			{
				dokl=x;
				kto=i;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		vector <pair<ld,pdd>>dys;
		for (int j=0; j<m; j++)
			dys.push_back({abs(kan[kto].second-odl(kan[kto].first, znam[j])), znam[j]});
		sort(dys.begin(), dys.end());
		znam.clear();
		for (int j=n; j<m; j++)
			znam.push_back(dys[j].second);
		m-=n;
		//~ ld x=dys[n-1];
		//~ if (x<dokl)
		//~ {
			//~ dokl=x;
			//~ kto=i;
		//~ }
		//~ for (int j=0; j<m; j++)
		//~ {
			//~ if (zawie(kan[kto], znam[j]))
			//~ {
				//~ m--;
				//~ swap(znam[j], znam[m]);
				//~ znam.pop_back();
				//~ j--;
			//~ }
		//~ }
	}
	return 0;
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.2;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}

	vector <pair<pdd,ld>> kan;

	for (int h=0; h<100000; h++)
	{
		int ile=los(2, 4);
		vector <pdd> daj;
		for (int i=0; i<ile; i++)
			daj.push_back(znam[los(0, m-1)]);
		pdd x=sr(daj);
		ld y=0;
		for (pdd j : daj)
			y+=odl(j, x);
		y/=ile;
		kan.push_back({x, y});
	}
	for (int h=0; h<k; h++)
	{
		int ile=-1;
		int kto=-1;
		ld dokl=0;
		for (int i=0; i<(int)kan.size(); i++)
		{
			int x=0;
			ld ter=0;
			for (int j=0; j<m; j++)
			{
				if (zawie(kan[i], znam[j]))
				{
					x++;
					ter+=odl(kan[i].first, znam[j]);
				}
			}
			if (x)
			{
				ter/=x;
				ter=abs(ter-kan[i].second);
			}
			if (x>ile || (x==ile && ter<dokl))
			{
				ile=x;
				kto=i;
				dokl=ter;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		for (int j=0; j<m; j++)
		{
			if (zawie(kan[kto], znam[j]))
			{
				m--;
				swap(znam[j], znam[m]);
				znam.pop_back();
				j--;
			}
		}
	}
	return 0;
}

//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=4007;
using ld=double;
using pdd=pair<ld,ld>;

int k, n, m;
vector <pdd> znam;

pdd operator + (pdd a, pdd b)
{
	return {a.first+b.first, a.second+b.second};
}

pdd operator - (pdd a, pdd b)
{
	return {a.first-b.first, a.second-b.second};
}

pdd operator * (pdd a, ld b)
{
	return {a.first*b, a.second*b};
}

pdd operator / (pdd a, ld b)
{
	return {a.first/b, a.second/b};
}

ld dlu(pdd v)
{
	return sqrt(v.first*v.first+v.second*v.second);
}

ld odl(pdd a, pdd b)
{
	return dlu(a-b);
}

pdd sr(vector <pdd> wek)
{
	pdd ret{0, 0};
	for (pdd i : wek)
		ret=ret+i;
	return ret/wek.size();
}

int los(int a, int b)
{
	return a+rand()%(b-a+1);
}

int zawie(pair <pdd,ld> a, pdd b)
{
	ld mag=0.15;
	ld y=odl(a.first, b);
	return ((1-mag)*a.second<=y && y<=(1+mag)*a.second);
}

int main()
{
	scanf("%d%d", &k, &n);
	m=k*n;
	for (int i=1; i<=m; i++)
	{
		ld x, y;
		scanf("%lf%lf", &x, &y);
		znam.push_back({x, y});
	}

	vector <pair<pdd,ld>> kan;

	for (int h=0; h<100000; h++)
	{
		int ile=los(3, 5);
		vector <pdd> daj;
		for (int i=0; i<ile; i++)
			daj.push_back(znam[los(0, m-1)]);
		pdd x=sr(daj);
		ld y=0;
		for (pdd j : daj)
			y+=odl(j, x);
		y/=ile;
		kan.push_back({x, y});
	}
	for (int h=0; h<k; h++)
	{
		int ile=-1;
		int kto=-1;
		for (int i=0; i<(int)kan.size(); i++)
		{
			int x=0;
			for (int j=0; j<m; j++)
				x+=zawie(kan[i], znam[j]);
			if (x>ile)
			{
				ile=x;
				kto=i;
			}
		}
		printf("%lf %lf %lf\n", kan[kto].first.first, kan[kto].first.second, kan[kto].second);
		for (int j=0; j<m; j++)
		{
			if (zawie(kan[kto], znam[j]))
			{
				m--;
				swap(znam[j], znam[m]);
				znam.pop_back();
				j--;
			}
		}
	}
	return 0;
}

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
#include <ctime>

using namespace std;
typedef long double ld;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const { return x*x + y*y; }
    double dist() const { return sqrt((double)dist2()); }
    // angle to x-axis in interval [-pi, pi]
    double angle() const { return atan2(y, x); }
    P unit() const { return *this/dist(); } // makes dist()=1
    P perp() const { return P(-y, x); } // rotates +90 degrees
    P normal() const { return perp().unit(); }
    // returns point rotated 'a' radians ccw around the origin
    P rotate(double a) const {
        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
};

typedef Point<double> P;
double ccRadius(const P& A, const P& B, const P& C) {
    return (B-A).dist()*(C-B).dist()*(A-C).dist()/
            abs((B-A).cross(C-A))/2;
}
P ccCenter(const P& A, const P& B, const P& C) {
    P b = C-A, c = B-A;
    return A + (b*c.dist2()-c*b.dist2()).perp()/b.cross(c)/2;
}

const int MAXN = 5000;

int N, K;
P pt[MAXN];

pair <P, double> res[4];

ld cdist (pair <P, double> left, pair <P, double> right)
{
    return abs(left.first.x - right.first.x) + abs (left.first.y - right.first.y) + abs(left.second - right.second);
}

void gogo()
{
    int cval = 0;
    while (cval < K)
    {
        int a = rand() % (N * K), b = rand() % (N * K), c = rand() % (N * K);
        if (a == b || a == c || b == c) continue;
        if (!((pt[b]-pt[a]).cross(pt[c]-pt[a]))) continue;
        P cc = ccCenter(pt[a], pt[b], pt[c]);
        double rad = ccRadius(pt[a], pt[b], pt[c]);
        if (cc.dist() > 1010000 || rad < 240000 || rad > 760000) continue;

        bool bad = false;
        for (int i = 0; i < cval; i++)
        {
            if (cdist (res[i], make_pair (cc, rad)) < 350000)
                bad = true;
        }
        if (bad) continue;

        int nhit = 0;
        vector <double> v;
        for (int i = 0; i < N * K; i++)
        {
            double d = (cc-pt[i]).dist();
            if (d > 0.89 * rad && d < 1.11 * rad)
            {
                nhit++;
                v.push_back((cc-pt[i]).angle());
            }
        }
        sort(v.begin(), v.end());
        for (int i = 0; i + 1 < v.size(); i++)
            if (v[i+1] - v[i] > 1)
            {
                //if (nhit >= N)
                //    cout << v[i+1] - v[i] << "\n";
                bad = true;
            }
        if (bad) continue;

        if (nhit >= N)
        {
            res[cval] = make_pair (cc, rad);
            cval++;
        }
    }
}

int main()
{
    srand(time(NULL));
    cin >> K >> N;
    for (int i = 0; i < N * K; i++)
    {
        cin >> pt[i].x >> pt[i].y;
    }

    gogo();

    cout << fixed << setprecision(8);
    for (int i = 0; i < K; i++)
    {
        cout << res[i].first.x << " " << res[i].first.y << " " << res[i].second << "\n";
    }
}

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>
#include <ctime>

using namespace std;
typedef long double ld;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const { return x*x + y*y; }
    double dist() const { return sqrt((double)dist2()); }
    // angle to x-axis in interval [-pi, pi]
    double angle() const { return atan2(y, x); }
    P unit() const { return *this/dist(); } // makes dist()=1
    P perp() const { return P(-y, x); } // rotates +90 degrees
    P normal() const { return perp().unit(); }
    // returns point rotated 'a' radians ccw around the origin
    P rotate(double a) const {
        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
};

typedef Point<double> P;
double ccRadius(const P& A, const P& B, const P& C) {
    return (B-A).dist()*(C-B).dist()*(A-C).dist()/
            abs((B-A).cross(C-A))/2;
}
P ccCenter(const P& A, const P& B, const P& C) {
    P b = C-A, c = B-A;
    return A + (b*c.dist2()-c*b.dist2()).perp()/b.cross(c)/2;
}

const int MAXN = 5000;

int N, K;
P pt[MAXN];

pair <P, double> res[4];

ld cdist (pair <P, double> left, pair <P, double> right)
{
    return abs(left.first.x - right.first.x) + abs (left.first.y - right.first.y) + abs(left.second - right.second);
}

void gogo()
{
    while (true)
    {
        int cval = 0;
        while (cval < K)
        {
            int a = rand() % (N * K), b = rand() % (N * K), c = rand() % (N * K);
            if (a == b || a == c || b == c) continue;
            if (!((pt[b]-pt[a]).cross(pt[c]-pt[a]))) continue;
            P cc = ccCenter(pt[a], pt[b], pt[c]);
            double rad = ccRadius(pt[a], pt[b], pt[c]);
            if (cc.dist() > 1010000 || rad < 240000 || rad > 760000) continue;

            bool bad = false;
            for (int i = 0; i < cval; i++)
            {
                if (cdist (res[i], make_pair (cc, rad)) < 350000)
                    bad = true;
            }
            if (bad) continue;

            int nhit = 0;
            vector <double> v;
            for (int i = 0; i < N * K; i++)
            {
                double d = (cc-pt[i]).dist();
                if (d > 0.89 * rad && d < 1.11 * rad)
                {
                    nhit++;
                    v.push_back((cc-pt[i]).angle());
                }
            }
            sort(v.begin(), v.end());
            for (int i = 0; i + 1 < v.size(); i++)
                if (v[i+1] - v[i] > 1)
                {
                    //if (nhit >= N)
                    //    cout << v[i+1] - v[i] << "\n";
                    bad = true;
                }
            if (bad) continue;

            if (nhit >= N)
            {
                res[cval] = make_pair (cc, rad);
                cval++;
            }
        }

        bool bad = false;
        for (int i = 0; i < N * K; i++)
        {
            bool found = false;
            for (int j = 0; j < K; j++)
            {
                double d1 = res[j].second, d2 = (res[j].first-pt[i]).dist();
                if (d2 >= 0.75 * d1 && d2 <= 1.25 * d1)
                    found = true;
            }
            if (!found)
            {
                bad = true;
                break;
            }
        }
        if (!bad) break;
    }
}

int main()
{
    srand(time(NULL));
    cin >> K >> N;
    for (int i = 0; i < N * K; i++)
    {
        cin >> pt[i].x >> pt[i].y;
    }

    gogo();

    cout << fixed << setprecision(8);
    for (int i = 0; i < K; i++)
    {
        cout << res[i].first.x << " " << res[i].first.y << " " << res[i].second << "\n";
    }
}

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <set>
#include <cmath>

using namespace std;
typedef long double ld;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;

template<class T>
struct Point {
    typedef Point P;
    T x, y;
    explicit Point(T x=0, T y=0) : x(x), y(y) {}
    bool operator<(P p) const { return tie(x,y) < tie(p.x,p.y); }
    bool operator==(P p) const { return tie(x,y)==tie(p.x,p.y); }
    P operator+(P p) const { return P(x+p.x, y+p.y); }
    P operator-(P p) const { return P(x-p.x, y-p.y); }
    P operator*(T d) const { return P(x*d, y*d); }
    P operator/(T d) const { return P(x/d, y/d); }
    T dot(P p) const { return x*p.x + y*p.y; }
    T cross(P p) const { return x*p.y - y*p.x; }
    T cross(P a, P b) const { return (a-*this).cross(b-*this); }
    T dist2() const { return x*x + y*y; }
    double dist() const { return sqrt((double)dist2()); }
    // angle to x-axis in interval [-pi, pi]
    double angle() const { return atan2(y, x); }
    P unit() const { return *this/dist(); } // makes dist()=1
    P perp() const { return P(-y, x); } // rotates +90 degrees
    P normal() const { return perp().unit(); }
    // returns point rotated 'a' radians ccw around the origin
    P rotate(double a) const {
        return P(x*cos(a)-y*sin(a),x*sin(a)+y*cos(a)); }
};

typedef Point<double> P;
double ccRadius(const P& A, const P& B, const P& C) {
    return (B-A).dist()*(C-B).dist()*(A-C).dist()/
            abs((B-A).cross(C-A))/2;
}
P ccCenter(const P& A, const P& B, const P& C) {
    P b = C-A, c = B-A;
    return A + (b*c.dist2()-c*b.dist2()).perp()/b.cross(c)/2;
}

const int MAXN = 5000;

int N, K;
P pt[MAXN];

pair <P, double> res[4];

ld cdist (pair <P, double> left, pair <P, double> right)
{
    return abs(left.first.x - right.first.x) + abs (left.first.y - right.first.y) + abs(left.second - right.second);
}

void gogo()
{
    int cval = 0;
    while (cval < K)
    {
        int a = rand() % (N * K), b = rand() % (N * K), c = rand() % (N * K);
        if (a == b || a == c || b == c) continue;
        if (!((pt[b]-pt[a]).cross(pt[c]-pt[a]))) continue;
        P cc = ccCenter(pt[a], pt[b], pt[c]);
        double rad = ccRadius(pt[a], pt[b], pt[c]);
        if (cc.dist() > 1010000 || rad < 240000 || rad > 760000) continue;

        bool bad = false;
        for (int i = 0; i < cval; i++)
        {
            if (cdist (res[i], make_pair (cc, rad)) < 350000)
                bad = true;
        }
        if (bad) continue;

        int nhit = 0;
        for (int i = 0; i < N * K; i++)
        {
            double d = (cc-pt[i]).dist();
            if (d > 0.89 * rad && d < 1.11 * rad)
                nhit++;
        }
        if (nhit >= N)
        {
            res[cval] = make_pair (cc, rad);
            cval++;
        }
    }
}

int main()
{
    cin >> K >> N;
    for (int i = 0; i < N * K; i++)
    {
        cin >> pt[i].x >> pt[i].y;
    }

    gogo();

    cout << fixed << setprecision(8);
    for (int i = 0; i < K; i++)
    {
        cout << res[i].first.x << " " << res[i].first.y << " " << res[i].second << "\n";
    }
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 3));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[100], Ansy[100], qwq[100];

int tmp[100];

int cnt = 0;

mt19937_64 rng(233);

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	int t = 0;
	/*for(int i = 1; i <= k; i++) {
		double x = rd() * 1000000, y = rd() * 1000000, r = rd() * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int T = 1; T <= 100; T++) {
		double x = rd() * 2000000, y = rd() * 2000000, magic = getval(x, y);
		for(double step = 2000000; step > 100; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}
	for(int i = 1; i <= 30; i++) tmp[i] = i;
	sort(tmp + 1, tmp + 30 + 1, cmp);
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) printf("%.12lf %.12lf %.12lf\n", Ansx[i], Ansy[i], getr(Ansx[i], Ansy[i]));
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 1.5));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/*int t = 0;
	for(int i = 1; i <= k; i++) {
		double a = rd() * 3.1415926535, v = rd() * 1000000, x = cos(a) * v, y = sin(a) * v, r = fabs(rd()) * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -50; i <= 50; i++)
		for(int j = -50; j <= 50; j++) if(dis(0, 0, i * 20000, j * 20000) <= 1e6)
			Ansx[++cnt] = i * 20000, Ansy[cnt] = j * 20000, qwq[cnt] = getval(i * 20000, j * 20000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 2e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 1));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/*int t = 0;
	for(int i = 1; i <= k; i++) {
		double a = rd() * 3.1415926535, v = rd() * 1000000, x = cos(a) * v, y = sin(a) * v, r = fabs(rd()) * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -100; i <= 100; i++)
		for(int j = -100; j <= 100; j++) if(dis(0, 0, i * 10000, j * 10000) <= 1e6)
			Ansx[++cnt] = i * 10000, Ansy[cnt] = j  *10000, qwq[cnt] = getval(i * 10000, j * 10000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 4e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]) / 1e5, 2));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200], Ansy[200], qwq[200];

int tmp[200];

int cnt = 0;

mt19937_64 rng(233);

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	int t = 0;
	/*for(int i = 1; i <= k; i++) {
		double x = rd() * 1000000, y = rd() * 1000000, r = rd() * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int T = 1; T <= 100; T++) {
		double x = rd() * 2000000, y = rd() * 2000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}
	for(int i = 1; i <= 100; i++) tmp[i] = i;
	sort(tmp + 1, tmp + 100 + 1, cmp);
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) printf("%.12lf %.12lf %.12lf\n", Ansx[i], Ansy[i], getr(Ansx[i], Ansy[i]));
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n, tmp[200000], cnt = 0;

double X[4010], Y[4010], avg1[10010], avg2[10010], Ansx[200000], Ansy[1200000], qwq[200000];

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

vector <double> V;

double Do(double x, double y) {
    V.clear();
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 2));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];

}
double getval(double x, double y) {
    Do(x, y);
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n);
	return magic;
}

double getr(double x, double y) {
	Do(x, y);
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

bool cmp(int x, int y) {return qwq[x] < qwq[y];}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) scanf("%lf%lf", &X[i], &Y[i]);
	for(int i = -100; i <= 100; i++)
		for(int j = -100; j <= 100; j++) if(dis(0, 0, i * 10000, j * 10000) <= 1e6)
			Ansx[++cnt] = i * 10000, Ansy[cnt] = j * 10000, qwq[cnt] = getval(i * 10000, j * 10000);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 4e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 1));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(233);

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/* t = 0;
	for(int i = 1; i <= k; i++) {
		double x = rd() * 1000000, y = rd() * 1000000, r = rd() * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -100; i <= 100; i++)
		for(int j = -100; j <= 100; j++)
			Ansx[++cnt] = i * 10000, Ansy[cnt] = j * 10000, qwq[cnt] = getval(i * 10000, j * 10000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 2e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 2));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/*int t = 0;
	for(int i = 1; i <= k; i++) {
		double a = rd() * 3.1415926535, v = rd() * 1000000, x = cos(a) * v, y = sin(a) * v, r = fabs(rd()) * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -100; i <= 100; i++)
		for(int j = -100; j <= 100; j++) if(dis(0, 0, i * 10000, j * 10000) <= 1e6)
			Ansx[++cnt] = i * 10000, Ansy[cnt] = j  *10000, qwq[cnt] = getval(i * 10000, j * 10000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 2e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 1));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(233);

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/* t = 0;
	for(int i = 1; i <= k; i++) {
		double x = rd() * 1000000, y = rd() * 1000000, r = rd() * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -100; i <= 100; i++)
		for(int j = -100; j <= 100; j++)
			Ansx[++cnt] = i * 10000, Ansy[cnt] = j * 10000, qwq[cnt] = getval(i * 10000, j * 10000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 5e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 3));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/*int t = 0;
	for(int i = 1; i <= k; i++) {
		double a = rd() * 3.1415926535, v = rd() * 1000000, x = cos(a) * v, y = sin(a) * v, r = fabs(rd()) * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -50; i <= 50; i++)
		for(int j = -50; j <= 50; j++) if(dis(0, 0, i * 20000, j * 20000) <= 1e6)
			Ansx[++cnt] = i * 20000, Ansy[cnt] = j * 20000, qwq[cnt] = getval(i * 20000, j * 20000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 2e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 2));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/*int t = 0;
	for(int i = 1; i <= k; i++) {
		double a = rd() * 3.1415926535, v = rd() * 1000000, x = cos(a) * v, y = sin(a) * v, r = fabs(rd()) * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -50; i <= 50; i++)
		for(int j = -50; j <= 50; j++) if(dis(0, 0, i * 20000, j * 20000) <= 1e6)
			Ansx[++cnt] = i * 20000, Ansy[cnt] = j * 20000, qwq[cnt] = getval(i * 20000, j * 20000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 2e5) qwq[i] = 1e100;
	}
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 3));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200], Ansy[200], qwq[200];

int tmp[200];

int cnt = 0;

mt19937_64 rng(233);

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	int t = 0;
	/*for(int i = 1; i <= k; i++) {
		double x = rd() * 1000000, y = rd() * 1000000, r = rd() * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int T = 1; T <= 100; T++) {
		double x = rd() * 2000000, y = rd() * 2000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}
	for(int i = 1; i <= 100; i++) tmp[i] = i;
	sort(tmp + 1, tmp + 100 + 1, cmp);
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) printf("%.12lf %.12lf %.12lf\n", Ansx[i], Ansy[i], getr(Ansx[i], Ansy[i]));
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]) / 1e5, 7));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200], Ansy[200], qwq[200];

int tmp[200];

int cnt = 0;

mt19937_64 rng(233);

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	int t = 0;
	/*for(int i = 1; i <= k; i++) {
		double x = rd() * 1000000, y = rd() * 1000000, r = rd() * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int T = 1; T <= 100; T++) {
		double x = rd() * 2000000, y = rd() * 2000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}
	for(int i = 1; i <= 100; i++) tmp[i] = i;
	sort(tmp + 1, tmp + 100 + 1, cmp);
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) printf("%.12lf %.12lf %.12lf\n", Ansx[i], Ansy[i], getr(Ansx[i], Ansy[i]));
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 5));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[100], Ansy[100], qwq[100];

int tmp[100];

int cnt = 0;

mt19937_64 rng(233);

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	int t = 0;
	/*for(int i = 1; i <= k; i++) {
		double x = rd() * 1000000, y = rd() * 1000000, r = rd() * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int T = 1; T <= 30; T++) {
		double x = rd() * 2000000, y = rd() * 2000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}
	for(int i = 1; i <= 30; i++) tmp[i] = i;
	sort(tmp + 1, tmp + 30 + 1, cmp);
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) printf("%.12lf %.12lf %.12lf\n", Ansx[i], Ansy[i], getr(Ansx[i], Ansy[i]));
	return 0;
}

#include <bits/stdc++.h>

using namespace std;

int k, n;

double X[4010], Y[4010];

double eps = 1e4, mx = 2e6;

double sqr(double x) {return x * x;}

double dis(int a, int b, int c, int d) {return sqrt(sqr(c - a) + sqr(d - b));}

double avg1[10010], avg2[10010];

double getval(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(pow(dis(x, y, X[s], Y[s]), 1));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) magic = min(magic, avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) /  n);
	return magic;
}

double getr(double x, double y) {
	vector <double> V(0);
	for(int s = 1; s <= k * n; s++)
		V.push_back(dis(x, y, X[s], Y[s]));
	sort(V.begin(), V.end());
	for(int i = 0; i < V.size(); i++) avg1[i] = V[i], avg2[i] = V[i] * V[i];
	for(int i = 1; i < V.size(); i++) avg1[i] += avg1[i - 1], avg2[i] += avg2[i - 1];
	double magic = 1e100;
	int v;
	int n = ::n - 2;
	for(int i = n; i < V.size(); i++) {
		double s = avg2[i] - avg2[i - n] - sqr(avg1[i] - avg1[i - n]) / n;
		if(s < magic) magic = s, v = i;
	}
	return (avg1[v] - avg1[v - n]) / n;
}

double Ansx[200000], Ansy[1200000], qwq[200000];

int tmp[200000];

int cnt = 0;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

double rd() {
	return (double) rng() / pow(2, 63) - 1;
}

bool cmp(int x, int y) {
	return qwq[x] < qwq[y];
}

int main() {
	scanf("%d%d", &k, &n);
	for(int i = 1; i <= k * n; i++) {
		scanf("%lf%lf", &X[i], &Y[i]);
		//X[i + n] = X[i] + 233333, Y[i + n] = Y[i] + 377777;
	}
	/*int t = 0;
	for(int i = 1; i <= k; i++) {
		double a = rd() * 3.1415926535, v = rd() * 1000000, x = cos(a) * v, y = sin(a) * v, r = fabs(rd()) * 500000 + 250000;
		printf("%.12lf %.12lf %.12lf\n", x, y, r);
		for(int j = 1; j <= n; j++) {
			double s = rd() * 3.1415926535, o = rd() * 50000, f = rd() * 3.1415926535;
			X[++t] = x + o * cos(s) + r * cos(f);
			Y[t] = y + o * sin(s) + r * sin(f);
		}
	}*/
	for(int i = -50; i <= 50; i++)
		for(int j = -50; j <= 50; j++) if(dis(0, 0, i * 20000, j * 20000) <= 1e6)
			Ansx[++cnt] = i * 20000, Ansy[cnt] = j * 20000, qwq[cnt] = getval(i * 20000, j * 20000);
	/*for(int T = 1; T <= 100; T++) {
		double x = rd() * 1000000, y = rd() * 1000000, magic = getval(x, y);
		for(double step = 2000000; step > 1000; step *= 0.95) {
			double dx = rd() * step, dy = rd() * step, tmp = getval(x + dx, y + dy);
			if(magic > tmp) x += dx, y += dy, magic = tmp;
		}
		int flag = 1;
		for(int i = 1; i <= cnt; i++)
			if(dis(x, y, Ansx[i], Ansy[i]) <= 1e5) flag = 0;
		if(flag && fabs(x) <= 2000000 && fabs(y) <= 2000000 && getr(x, y) >= 200000 && getr(x, y) <= 800000) Ansx[++cnt] = x, Ansy[cnt] = y, qwq[cnt] = magic;
	}*/
	//printf("%.12lf %.12lf\n", getval(Ansx[1], Ansy[1]), getval(Ansx[1] + 233333, Ansy[1] + 377777));
	//assert(cnt == k);
	for(int i = 1; i <= k; i++) {
		for(int i = 1; i <= cnt; i++) tmp[i] = i;
		sort(tmp + 1, tmp + cnt + 1, cmp);
		printf("%.12lf %.12lf %.12lf\n", Ansx[tmp[1]], Ansy[tmp[1]], getr(Ansx[tmp[1]], Ansy[tmp[1]]));
		double x = Ansx[tmp[1]], y = Ansy[tmp[1]];
		for(int i = 1; i <= cnt; i++) if(dis(Ansx[i], Ansy[i], x, y) <= 2e5) qwq[i] = 1e100;
	}
	return 0;
}