The Cybermen have again outwitted the Daleks! Unfortunately, this time the Daleks decided to abandon these tasks altogether, which means the Doctor has to deal with them.The Doctor can handle the Daleks on his own, but Heidi now has to make sure that the Cybermen are kept busy with this next task.There are $$$k$$$ rings on a plane. For each ring, $$$n$$$ points are uniformly sampled with a small random noise. The task is to recover the rings given only the noisy samples.The rings and the samples are generated as follows. The center of a ring is uniformly sampled from a disk of radius $$$1\,000\,000$$$ centered at the origin, and the radius of the ring is uniformly sampled from $$$[250\,000, 750\,000]$$$. Let $$$R$$$ be a ring with center $$$(x, y)$$$ and radius $$$r$$$. To sample a point from $$$R$$$, an angle $$$\theta$$$ is uniformly sampled from $$$[0, 2\pi]$$$ and a distance $$$d$$$ is uniformly sampled from $$$[0.9r, 1.1r]$$$. The coordinates of the sampled point are then $$$(x+d\cos(\theta), y+d\sin(\theta))$$$ rounded to the closest integers.The distance between rings is measured by their Hausdorff distance. In our case, the distance between two rings $$$R_1, R_2$$$ can be written as follow. Let $$$d$$$ be the distance between the two centers and $$$r_1, r_2$$$ be the radii. Then the distance is $$$$$$dist(R_1, R_2)=\max(\min(d_{--}, d_{-+}),\min(d_{+-}, d_{++}), \min(d_{--}, d_{+-}), \min(d_{-+}, d_{++}))$$$$$$, where $$$d_{++}=|d+r_1+r_2|$$$, $$$d_{+-}=|d+r_1-r_2|$$$, $$$d_{-+}=|d-r_1+r_2|$$$, $$$d_{--}=|d-r_1-r_2|$$$.We say that a ring $$$R_0$$$ is recovered if one of the rings $$$R$$$ in the output has Hausdorff distance less than $$$100\,000$$$ from $$$R_0$$$. An output is accepted if all the rings are recovered. It is guaranteed that the distances between any two rings is greater than $$$600\,000$$$.Remember that a human can very easily solve this task, so make sure that no human traitors are helping the Cybermen complete this task.

The first line contains an integer $$$k$$$ ($$$1 \leq k \leq 4$$$), the number of rings. The second line contains an integer $$$n$$$ ($$$100 \leq n \leq 1\,000$$$), the number of samples per ring. The following $$$n \times k$$$ lines contain the samples, one sample per line. Each line contains a pair of integers $$$x_i, y_i$$$, where $$$(x_i, y_i)$$$ are the coordinates of the $$$i$$$-th sample.

Print $$$k$$$ lines, each describing a single ring. For each line, print three real numbers $$$x_i, y_i, r_i$$$, where $$$(x_i, y_i)$$$ and $$$r_i$$$ are the coordinates and the radius of the $$$i$$$-th ring. The order of the rings does not matter.

NoteHere is how one of tests with $$$k=4$$$ and $$$n=100$$$ looks like.   You can download the sample input and output here.

#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;

#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>
#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;
}

#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;
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;
      }
    }
  }
}

//~ 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>

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 <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;
}

#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;
}