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

typedef vector<double> Vec;
const double eps = 1e-8;
int sgn(double x) {
    if(fabs(x) < eps) return 0;
    return x > 0 ? 1 : -1;
}
// 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: {success, a special solution, orthonormal null space of A}
tuple<bool, Vec, vector<Vec>> gram_schmidt(vector<Vec> a) {
    int m = sz(a), d = sz(a[0])-1, 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]) && (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];
            rep(k,0,d+1) a[j][k] -= a[pos][k] * f;
        }
        double val = a[pos][i];
        rep(k,0,d+1) a[pos][k] /= val;
        leftp.push_back(i);
        pos++;
    }
    while(sz(a) > 0) {
        const auto &last = a.back();
        bool last_zero = fabs(last[d]) < eps;
        bool pre_zero = true;
        rep(i,0,d) pre_zero = pre_zero && fabs(last[i]) < eps;
        if(pre_zero) {
            if(!last_zero) return {false, Vec(0,0), {}}; // no solution.
            a.pop_back();
        } else {
            break;
        }
    }
    Vec sol(d, 0.0); // special solution
    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]];
            rep(k,0,d+1) a[j][k] -= a[i][k] * f;
        }
    }
    vector<Vec> res; // orthonormal null space of A.
    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) {
            double prod = 0;
            rep(i,0,d) prod += c[i]*g[i];
            rep(i,0,d) c[i] -= prod*g[i];
        }
        double norm = 0;
        rep(i,0,d) norm+=c[i]*c[i];
        norm = sqrt(norm);
        rep(i,0,d) c[i]/=norm;
        res.push_back(c);
    }
    return {true, 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]);
    }
    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 [success, sol, res] = gram_schmidt(mat);
    assert(success);
    if(sz(res) == 0) {
        rep(i,0,d) {
            printf("%.11f%c", sol[i]," \n"[i==d-1]);
        }
        return;
    }
    // the ball -- centered at a[n-1] with e[n-1]
    Vec min_vec = sol;
    rep(i,0,d) min_vec[i] -= a[n-1][i];
    for(auto g: res) {
        double prod = 0;
        rep(i,0,d) prod += min_vec[i] * g[i];
        rep(i,0,d) min_vec[i] -= g[i] * prod;
    }
    double min_vec_length_sqr = 0;
    rep(i,0,d) min_vec_length_sqr += min_vec[i]*min_vec[i];
    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);
    auto final_point = a[n-1];
    rep(i,0,d) final_point[i] += min_vec[i];
    if(walk_dist >= 5e-6) {
        assert(sz(res) > 0);
        rep(i,0,d) final_point[i] += res[sz(res)-1][i]*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;
}