#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<ld, 3>;

const int N = 1000;

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

ld 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;
        }
    }

    vector<vector<ld>> dists2(n, vector<ld>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            dists2[i][j] = sqr(dists[i][j]);
        }
    }

    vector<P> ans(n);
    ans[0] = {0, 0, 0};

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

    auto g = [&](int x) {
        return ld(x) / N;
    };

    for (int i = 1; i < n; i++) {
        ld best = 1e18;
        int z = -N;
        for (int x = -N; x <= N; x++) {
            for (int y = -N; y <= N; y++) {
                ld gx = g(x), gy = g(y);
                auto f = [&](int z) {
                    ld gz = g(z);
                    ld f = 0;
                    for (int j = 0; j < i; j++) {
                        f = max(f, fabs(dists2[i][j] - dist(ans[j], {gx, gy, gz})));
                    }
                    return f;
                };

                ld cur = f(z);
                while (true) {
                    ld nxt = f(z + 1);
                    if (nxt < cur) {
                        cur = nxt;
                        z++;
                    } else {
                        break;
                    }
                }
                while (true) {
                    ld nxt = f(z - 1);
                    if (nxt < cur) {
                        cur = nxt;
                        z--;
                    } else {
                        break;
                    }
                }
                if (cur < best) {
                    best = cur;
                    ans[i] = {gx, gy, g(z)};
                }
            }
        }
    }

    // cout << get_error() << endl;
    const ld EPS = 0.09999;

    ld temp = 0.001;
    int iteration = 0;
    while (get_error() > 0.1) {
        vector<P> force(n);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j) {
                    continue;
                }
                P vec;
                for (int k = 0; k < 3; k++) {
                    vec[k] = ans[j][k] - ans[i][k];
                }

                ld cur = sqrt(dist(ans[i], ans[j]));
                ld expected = dists[i][j];
                if (cur > expected + EPS) {
                    ld coeff = cur - (expected + EPS);
                    for (int k = 0; k < 3; k++) {
                        force[i][k] += vec[k] * coeff;
                    }
                } else if (cur < expected - EPS) {
                    ld coeff = (expected - EPS) - cur;
                    for (int k = 0; k < 3; k++) {
                        force[i][k] -= vec[k] * coeff;
                    }
                }
            }
        }

        for (int i = 0; i < n; i++) {
            for (int k = 0; k < 3; k++) {
                ans[i][k] += force[i][k] * temp;
            }
        }

        // temp *= 0.99999;
        iteration++;
        if (iteration % int(1e6) == 0) {
            cout << iteration << ": " << get_error() << endl;
        }
    }

    for (auto [x, y, z] : ans) {
        cout << x << ' ' << y << ' ' << z << '\n';
    }
}