#pragma GCC optimize("unroll-loops,O3")

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

using ll = long long;
using ld = double;

#define all(a) begin(a), end(a)
#define len(a) int((a).size())

using P = array<int, 3>;

const int N = 100;

int sqr(int x) {
    return x * x;
}

int dist(P a, P b) {
    return sqr(a[0] - b[0]) + sqr(a[1] - b[1]) + sqr(a[2] - b[2]);
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    cout << fixed << setprecision(10);

    int n;
    cin >> n;
    vector<vector<ld>> dists(n, vector<ld>(n));
    for (auto &v : dists) {
        for (auto &x : v) {
            cin >> x;
            x = x * x * N * N;
        }
    }

    while (true) {

        vector<P> ans(n);
        ans[0] = {0, 0, 0};
        for (int i = 1; i < n; i++) {
            ld best = 1e18;
            for (int x = -N; x <= N; x++) {
                for (int y = -N; y <= N; y++) {
                    for (int z = -N; z <= N; z++) {
                        ld sum = 0;
                        for (int j = 0; j < i; j++) {
                            sum = max(sum, fabs(dists[i][j] - dist(ans[j], {x, y, z})));
                            // sum += dists[i][j] - dist(ans[j], {x, y, z});
                        }
                        if (sum < best) {
                            best = sum;
                            ans[i] = {x, y, z};
                        }
                    }
                }
            }
        }

        auto get_error = [&]() {
            ld max_error = 0;
            for (int i = 0; i < n; i++) {
                for (int j = i + 1; j < n; j++) {
                    ld cur_dist = dist(ans[i], ans[j]);
                    cur_dist /= N * N;
                    ld expected = dists[i][j] / N / N;
                    cur_dist = sqrt(cur_dist);
                    expected = sqrt(expected);
                    max_error = max(max_error, fabs(expected - cur_dist));
                }
            }
            return max_error;
        };

        if (get_error() > 0.0999) {
            continue;
        }
        // cerr << "error: " << get_error() << '\n';
        for (auto [x, y, z] : ans) {
            cout << ld(x) / N << ' ' << ld(y) / N << ' ' << ld(z) / N << '\n';
        }
        return 0;
    }
}