#include <bits/stdc++.h>
#ifdef LOCAL
#include "cp_debug.h"
#else
#define debug(...) 42
#endif
#define rep(i,a,b) for(int i = a; i < b; ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;

template<typename T> void read(T &x){
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
    read(first);
    read(args...);
}
template<typename T> void write(T x) {
    if(x > 9) write(x/10);
    putchar(x%10 + '0');
}

const double eps = 1e-11;
int sgn(double x) {
    if(fabs(x) < eps) return 0;
    return x > 0 ? 1 : -1;
}

struct Vec : public vector<double> {
    Vec(size_t siz, double val): vector(siz, val) { }
#define v (*this)
    double operator * (const Vec& rhs) const {
        assert(sz(v) == sz(rhs));
        double res = 0;
        for(int i = 0; i < sz(v); ++i)
            res += v[i] * rhs[i];
        return res;
    }
    Vec operator + (const Vec& rhs) const {
        assert(sz(v) == sz(rhs));
        Vec res(sz(v), 0);
        for(int i = 0; i < sz(v); ++i) res[i] = v[i] + rhs[i];
        return res;
    }
    Vec operator - (const Vec& rhs) const {
        assert(sz(v) == sz(rhs));
        Vec res(sz(v), 0);
        for(int i = 0; i < sz(v); ++i) res[i] = v[i] - rhs[i];
        return res;
    }
    Vec operator += (const Vec& rhs) { 
        assert(sz(v) == sz(rhs));
        for(int i = 0; i < sz(v); ++i) v[i] += rhs[i]; return v;
    }
    Vec operator -= (const Vec& rhs) { 
        assert(sz(v) == sz(rhs));
        for(int i = 0; i < sz(v); ++i) v[i] -= rhs[i]; return v; 
    }
    Vec operator * (double k) const { 
        Vec res(v); for(auto &g : res) g *= k; 
        return res;
    }
    Vec operator /= (double k) {
        for(auto &g: v) g /= k; 
        return v;
    }
    void do_normalize() { v /= sqrt(v * v); }
    void show() const {
        for(int i = 0; i < sz(v); ++i)
            printf("%.12f%c", v[i], " \n"[i == sz(v) - 1]);
    }
#undef v
};
double dis(const Vec& A, const Vec& B) { return (A - B) * (A - B); }

// input: m x (d+1) matrix, meaning [A, b] in Ax=b.
// \sum_{j=0}^{d-1} a[i][j] * x[j] = a[i][d].
// returns:
tuple<vi, vi, Vec, vector<Vec>> gaussian_elimination(vector<Vec> a) {
    int m = sz(a), d = sz(a[0])-1;
    int pos = 0, rc = 0;
    vector<int> fre(d), leftp;
    rep(i, 0, d) {
        int op = -1;
        for(int j = pos; j < m; j++) {
            if(sgn(a[j][i])) {
                if(op == -1 || fabs(a[j][i]) > fabs(a[op][i])) {
                    op = j;
                }
            }
        }
        if(op == -1) {
            fre[i] = ++rc;
            continue;
        }
        fre[i] = 0;
        if(op != pos) {
            swap(a[pos], a[op]);
        }
        for(int j = pos+1; j < m; j++) {
            double f = a[j][i] / a[pos][i];
            a[j] -= a[pos] * f;
        }
        a[pos] /= a[pos][i];
        leftp.push_back(i);
        pos++;
    }
    debug(fre, leftp);
    debug("G", a);
    while(sz(a) > 0) {
        const auto &last = a.back();
        bool last_zero = fabs(last[d]) < 1000*eps;
        bool pre_zero = true;
        rep(i,0,d) pre_zero = pre_zero && fabs(last[i]) < 1000*eps;
        if(pre_zero) {
            assert(last_zero);
            a.pop_back();
        } else {
            break;
        }
    }
    assert(sz(a) == sz(leftp));
    assert(sz(a) <= d);
    debug("DROP", a);

    // solution
    Vec sol(d, 0.0);
    for(int i = sz(a)-1; i >= 0; --i) {
        assert(sgn(a[i][leftp[i]] - 1.0) == 0);
        sol[leftp[i]] = a[i][d];
        rep(j,0,i) {
            double f = a[j][leftp[i]];
            a[j] -= a[i] * f;
        }
    }
    debug(sol);

    // orthonormal null space of A.
    vector<Vec> res;
    for(int f = 1; f <= rc; ++f) {
        Vec c(d, 0);
        for(int i = 0; i < d; ++i) if(fre[i] == f) c[i] = 1;
        for(int i = sz(a)-1; i >= 0; --i) {
            for(int j = leftp[i] + 1; j < d; ++j) {
                c[leftp[i]] -= c[j] * a[i][j];
            }
        }
        for(auto g : res) c -= g * (c * g);
        c.do_normalize();
        res.push_back(c);
    }
    debug(res);
    return {fre, leftp, sol, res};
}

void solve() {
    int d, n;
    read(d, n);
    vector<Vec> a(n, Vec(d, 0.0));
    Vec e(n, 0), norm2(n, 0);
    rep(i,0,n) {
        rep(j,0,d) {
            scanf("%lf", &a[i][j]);
            norm2[i] += a[i][j] * a[i][j];
        }
        scanf("%lf", &e[i]);
    }
    // mat[i][d] -- rhs
    vector<Vec> mat(n-1, Vec(d+1, 0.0));
    rep(i,0,n-1) {
        rep(j,0,d) {
            mat[i][j] = (a[i][j]-a[n-1][j]);
        }
        mat[i][d] = 0.5 * ((norm2[i]-norm2[n-1]) - e[i]*e[i] + e[n-1]*e[n-1]);
    }
    debug(mat);
    if(n == 1) {
        rep(i,0,d) {
            printf("%.11f%c", a[0][i]+(i==0?e[0]:0)," \n"[i==d-1]);
        }
        return;
    }
    // the plane -- sol + C*res for any C in R^{dim(null(A))}
    auto [fre, leftp, sol, res] = gaussian_elimination(mat);
    // the ball -- centered at a[n-1] with e[n-1]
    auto min_vec = sol - a[n-1];
    for(auto g: res) {
        min_vec -= g * (min_vec * g);
    }
    double min_vec_length_sqr = min_vec*min_vec;
    assert(min_vec_length_sqr <= e[n-1]*e[n-1]);
    double walk_dist = sqrt(e[n-1]*e[n-1]-min_vec_length_sqr);
    debug(walk_dist);
    auto final_point = a[n-1]+min_vec;
    debug(final_point);
    if(walk_dist >= 1e-6) {
        assert(sz(res) > 0);
        final_point += res[0]*walk_dist;
    }
    rep(i,0,d) {
        printf("%.11f%c", final_point[i]," \n"[i==d-1]);
    }
}

signed main() {
    int T; T = 1;
    while(T--) solve();
    return 0;
}