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

const double eps = 1e-9, inf = 1e9;

class Vec : public vector<double> {
  public:
    Vec() : vector<double>() {}
    Vec(size_t n) : vector<double>(n) {}
    Vec& operator-=(const Vec& oth) {
      for (size_t i = 0; i < size(); i++) {
        (*this)[i] -= oth[i];
      }
      return *this;
    }
    Vec operator*(const double k) {
      Vec result(size());
      for (size_t i = 0; i < size(); i++) {
        result[i] = (*this)[i] * k;
      }
      return result;
    }
};

double dot(const Vec& a, const Vec& b) {
  assert(a.size() == b.size());
  double r = 0;
  for (int i = 0; i < a.size(); i++)
    r += a[i]*b[i];
  return r;
}

int d, n;
double transl[505], radius;
int pivot[505];
bool ispivot[505];

int main() {
  scanf("%d%d", &d, &n);
  --n;
  for (int i = 0; i < d; i++)
    scanf("%lf", transl+i);
  scanf("%lf", &radius);
  //if (n == 0) {
    //printf("%lf", transl[0] + radius);
    //for (int i = 1; i < d; i++)
      //printf(" %lf", transl[i]);
    //return 0;
  //}

  vector<Vec> vs;
  for (int i = 0; i < n; i++) {
    Vec v(d+1);
    double sumsq = 0;
    for (int j = 0; j < d; j++) {
      double x; scanf("%lf", &x);
      x -= transl[j];
      v[j] = -2*x;
      sumsq += x*x;
    }
    double r; scanf("%lf", &r);
    v[d] = r*r - sumsq - radius*radius;
    vs.push_back(v);
  }

  for (int i = 0; i < n; i++) {
    // Find a pivot row
    int r = -1;
    for (int j = i; j < n; j++)
      if (fabs(vs[j][i]) > eps) {
        r = j;
        break;
      }
    if (r == -1)
      continue;  // None found
    if (r != i)
      swap(vs[r], vs[i]);
    vs[i] = vs[i] * (1/vs[i][i]);
    for (int j = 0; j < n; j++)
      if (j != i)
        vs[j] -= vs[i] * vs[j][i];
  }

  // Get orthonormal basis and translation for affine space
  Vec translation(d);
  for (int i = 0; i < n; i++) {
    while (pivot[i] < d && fabs(vs[i][pivot[i]]) < eps)
      pivot[i]++;
    if (pivot[i] == d)
      assert(fabs(vs[i][d]) < eps);  // Solution exists
    // Get information from row
    translation[pivot[i]] = vs[i][d];
    ispivot[pivot[i]] = true;
  }
  vector<Vec> basis;
  for (int i = 0; i < d; i++)
    if (!ispivot[i]) {
      Vec bvec(d);
      bvec[i] = -1;
      for (int j = 0; j < n; j++)
        if (pivot[j] < d)
          bvec[pivot[j]] = vs[j][i];
      basis.push_back(bvec);
    }

  // Gram schmidt
  for (int i = 0; i < basis.size(); i++) {
    for (int j = 0; j < i; j++)
      basis[i] -= basis[j] * (dot(basis[i], basis[j])/dot(basis[j], basis[j]));
    basis[i] = basis[i] * (1/sqrt(dot(basis[i], basis[i])));
  }

  // Now get projection
  for (int i = 0; i < basis.size(); i++)
    translation -= basis[i] * (dot(translation, basis[i])/dot(basis[i], basis[i]));
  if (basis.size() > 0) {
    double alpha = sqrt(max(eps, radius*radius-dot(translation, translation)));
    translation -= basis[0]*(-alpha);
  }

  for (int i = 0; i < d; i++)
    printf("%.9lf ", translation[i]+transl[i]);
  printf("\n");
  return 0;
}