#if __INCLUDE_LEVEL__ == 0

#include __BASE_FILE__

Xorshift rnd;

void Solve() {
  int n;
  IN(n);
  vector d(n, vector<double>(n));
  IN(d);

  vector<array<double, 3>> p(n);
  for (int i : Rep(0, n)) {
    ranges::generate(p[i], LIFT(rnd.Uniform));
  }

  auto Eval = [&](double) -> double {
    double mx = 0;
    double sum = 0;
    for (int i : Rep(0, n)) {
      for (int j : Rep(i + 1, n)) {
        double db = hypot(p[j][0] - p[i][0],
                          p[j][1] - p[i][1],
                          p[j][2] - p[i][2]);
        // SetMax(mx, abs(db - d[i][j]));
        sum += (db - d[i][j]) * (db - d[i][j]);
      }
    }
    // return sqrt(sum) * (1 - t) + mx;
    return sum;
  };

  PARAM(double, TL, 2.8);
  PARAM(double, T0, 1.0);
  PARAM(double, T1, 1e-5);

  double cur = Eval(0.0);

  double best = cur;
  auto best_p = p;

  for (const auto& sa : SimulatedAnnealing<256>(rnd, TL, T0, T1)) {
    int i = rnd.Int(0, n - 1);
    int axis = rnd.Int(0, 2);
    double L = pow(0.01, 1.0 - sa.cur_time) * pow(0.001, sa.cur_time);
    double delta = rnd.Uniform(-L, L);
    // double nxt = Eval(sa.cur_time);
    double nxt = cur;
    for (int j : Rep(0, n) | FILTER(j, j != i)) {
      double db = hypot(p[j][0] - p[i][0],
                        p[j][1] - p[i][1],
                        p[j][2] - p[i][2]);
      nxt -= (db - d[i][j]) * (db - d[i][j]);
    }
    p[i][axis] += delta;
    for (int j : Rep(0, n) | FILTER(j, j != i)) {
      double db = hypot(p[j][0] - p[i][0],
                        p[j][1] - p[i][1],
                        p[j][2] - p[i][2]);
      nxt += (db - d[i][j]) * (db - d[i][j]);
    }

    if (nxt > cur + sa.tol) {
      p[i][axis] -= delta;
    } else {
      cur = nxt;
    }

    if (SetMin(best, cur)) {
      best_p = p;
      if ([&] {
            double mx = 0;
            for (int i : Rep(0, n)) {
              for (int j : Rep(i + 1, n)) {
                double db = hypot(p[j][0] - p[i][0],
                                  p[j][1] - p[i][1],
                                  p[j][2] - p[i][2]);
                if (abs(db - d[i][j]) > 0.0999999) {
                  return false;
                }
              }
            }
            return true;
          }()) {
        break;
      }
      cur = Eval(0.0);
    }
  }

  OUT(best_p);
}

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

  Solve();
}

#elif __INCLUDE_LEVEL__ == 1

#include <bits/stdc++.h>

__attribute__((constructor)) inline double ElapsedTime() {
  using namespace std::chrono;
  static const auto T0 = steady_clock::now();
  return duration<double>(steady_clock::now() - T0).count();
}

class Xorshift {
 public:
  using result_type = uint64_t;
  static constexpr result_type min() { return 0; }
  static constexpr result_type max() { return UINT64_MAX; }
  result_type operator()() { return Next(); }

  Xorshift() : Xorshift(std::chrono::steady_clock::now().time_since_epoch().count()) {}

  explicit Xorshift(uint64_t seed) {
    std::ranges::generate(x_, std::mt19937_64(seed));
  }

  uint64_t Next() {
    if (++p_ == N) {
      p_ = 0;
      for (int i = 0; i < N; ++i) {
        x_[i] ^= x_[i] << 7;
        x_[i] ^= x_[i] >> 9;
      }
    }
    return x_[p_];
  }

  int Int(int a, int b) {
    uint64_t r = Next() >> 32;
    return a + int(r * (b - a + 1) >> 32);
  }

  int64_t Int(int64_t a, int64_t b) {
    __uint128_t r = Next();
    return a + int64_t(r * (b - a + 1) >> 64);
  }

  std::pair<int, int> Int2(int a, int b) {
    auto r = std::bit_cast<std::array<uint32_t, 2>>(Next());
    int x = a + int(r[0] * uint64_t(b - a) >> 32);
    int y = a + int(r[1] * uint64_t(b - a + 1) >> 32);
    if (y == x) {
      y = b;
    } else if (y < x) {
      std::swap(x, y);
    }
    return {x, y};
  }

  double Uniform() {
    return double(Next()) / double(UINT64_MAX);
  }

  double Uniform(double a, double b) {
    return a + Uniform() * (b - a);
  }

 private:
  static constexpr int N = 8;

  std::array<uint64_t, N> x_;
  int p_ = -1;
};

template <class D>
class RangeBase {
  struct I {
    D* self;
    bool operator!=(int) const { return self->IsValid(); }
    void operator++() { self->Advance(); }
    auto operator*() const { return self->Get(); }
  };

 public:
  I begin() { return {static_cast<D*>(this)}; }
  int end() const { return 0; }
};

template <int UpdateInterval = 1>
class SimulatedAnnealing : public RangeBase<SimulatedAnnealing<UpdateInterval>> {
 public:
  SimulatedAnnealing(Xorshift& rnd, double time_limit, double start_temp, double end_temp)
      : rnd_(&rnd),
        start_time_(ElapsedTime()),
        time_limit_(time_limit),
        start_temp_(start_temp),
        cooling_rate_(start_temp > 0.0 ? end_temp / start_temp : 1.0),
        iter_(0),
        cur_time_(0.0),
        temp_(start_temp) {
    assert(0.0 <= end_temp && end_temp <= start_temp);
  }

 private:
  friend RangeBase<SimulatedAnnealing>;

  bool IsValid() const {
    return cur_time_ < 1.0;
  }

  void Advance() {
    if (++iter_ % UpdateInterval == 0) {
      cur_time_ = (ElapsedTime() - start_time_) / time_limit_;
      temp_ = start_temp_ * std::pow(cooling_rate_, cur_time_);
    }
  }

  auto Get() const {
    struct {
      int64_t iter;
      double cur_time;
      double temp;
      double tol;
    } ret{iter_, cur_time_, temp_, temp_ * -std::log(rnd_->Uniform())};
    return ret;
  }

  Xorshift* rnd_;
  double start_time_;
  double time_limit_;
  double start_temp_;
  double cooling_rate_;
  int64_t iter_;
  double cur_time_;
  double temp_;
};

template <class T> concept Range = std::ranges::range<T> && !std::convertible_to<T, std::string_view>;
template <class T> concept Tuple = std::__is_tuple_like<T>::value && !Range<T>;

namespace std {

istream& operator>>(istream& is, Range auto&& r) {
  for (auto&& e : r) is >> e;
  return is;
}
istream& operator>>(istream& is, Tuple auto&& t) {
  apply([&](auto&... xs) { (is >> ... >> xs); }, t);
  return is;
}

ostream& operator<<(ostream& os, Range auto&& r) {
  auto sep = "";
  for (auto&& e : r) os << exchange(sep, " ") << e;
  return os;
}
ostream& operator<<(ostream& os, Tuple auto&& t) {
  auto sep = "";
  apply([&](auto&... xs) { ((os << exchange(sep, " ") << xs), ...); }, t);
  return os;
}

}  // namespace std

using namespace std;

#define LAMBDA(x, ...) ([&](auto&& x) -> decltype(auto) { return __VA_ARGS__; })
#define LAMBDA2(x, y, ...) ([&](auto&& x, auto&& y) -> decltype(auto) { return __VA_ARGS__; })
#define LIFT(f) ([&](auto&&... xs) -> decltype(auto) { return f(forward<decltype(xs)>(xs)...); })
#define FILTER(...) views::filter(LAMBDA(__VA_ARGS__))
#define Rep(...) [](int l, int r) { return views::iota(min(l, r), r); }(__VA_ARGS__)
#define SetMin(...) LAMBDA2(x, y, y < x && (x = y, 1))(__VA_ARGS__)
#define PARAM(T, NAME, val) constexpr T NAME = val
#define IN(...) (cin >> forward_as_tuple(__VA_ARGS__))
#define OUT(...) (cout << forward_as_tuple(__VA_ARGS__) << '\n')

#endif  // __INCLUDE_LEVEL__ == 1