#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
const ll ILL=2167167167167167167;
const int INF=2100000000;
#define rep(i,a,b) for (int i=(int)(a);i<(int)(b);i++)
#define all(p) p.begin(),p.end()
template<class T> using _pq = priority_queue<T, vector<T>, greater<T>>;
template<class T> int LB(vector<T> &v,T a){return lower_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> int UB(vector<T> &v,T a){return upper_bound(v.begin(),v.end(),a)-v.begin();}
template<class T> bool chmin(T &a,T b){if(b<a){a=b;return 1;}else return 0;}
template<class T> bool chmax(T &a,T b){if(a<b){a=b;return 1;}else return 0;}
template<class T> void So(vector<T> &v) {sort(v.begin(),v.end());}
template<class T> void Sore(vector<T> &v) {sort(v.begin(),v.end(),[](T x,T y){return x>y;});}
bool yneos(bool a,bool upp=false){if(a){cout<<(upp?"YES\n":"Yes\n");}else{cout<<(upp?"NO\n":"No\n");}return a;}
template<class T> void vec_out(vector<T> &p,int ty=0){
    if(ty==2){cout<<'{';for(int i=0;i<(int)p.size();i++){if(i){cout<<",";}cout<<'"'<<p[i]<<'"';}cout<<"}\n";}
    else{if(ty==1){cout<<p.size()<<"\n";}for(int i=0;i<(int)(p.size());i++){if(i) cout<<" ";cout<<p[i];}cout<<"\n";}}
template<class T> T vec_min(vector<T> &a){assert(!a.empty());T ans=a[0];for(auto &x:a) chmin(ans,x);return ans;}
template<class T> T vec_max(vector<T> &a){assert(!a.empty());T ans=a[0];for(auto &x:a) chmax(ans,x);return ans;}
template<class T> T vec_sum(vector<T> &a){T ans=T(0);for(auto &x:a) ans+=x;return ans;}
int pop_count(long long a){int res=0;while(a){res+=(a&1),a>>=1;}return res;}
template<class T> T square(T a){return a * a;}

//https://ei1333.github.io/library/other/xor-shift.cpp.html
struct XorShift {
private:
    constexpr static double R = 1.0 / 0xffffffff;
    uint64_t x;

public:
    explicit XorShift(uint64_t seed = 88172645463325252ull) : x(seed) {}

    template< typename T = uint64_t >
    inline T get() { // [0, 2^64)
        x ^= x << 7ull;
        x ^= x >> 9ull;
        return x;
    }

    inline uint32_t get(uint32_t r) { // [0, r)
        return ((uint64_t) get< uint32_t >() * r) >> 32ull;
    }

    inline uint32_t get(uint32_t l, uint32_t r) { // [l, r)
        return l + get(r - l);
    }

    inline double probability() { // [0.0, 1.0]
        return get< uint32_t >() * R;
    }
};

struct point {
    ld x = 0.5;
    ld y = 0.5;
    ld z = 0.5;
};

ld dist(point a, point b){
    return hypot(a.x - b.x, a.y - b.y, a.z - b.z);
}

point add(point a, point b){
    a.x += b.x;
    a.y += b.y;
    a.z += b.z;
    /*
    chmin(a.x, (ld)(1));
    chmax(a.x, (ld)(0));
    chmin(a.y, (ld)(1));
    chmax(a.y, (ld)(0));
    chmin(a.z, (ld)(1));
    chmax(a.z, (ld)(0));*/
    return a;
}

vector<vector<ld>> make(int N, int seed = 0){
    vector<point> a(N);
    XorShift table(seed);
    rep(i, 0, N){
        a[i].x = table.probability();
        a[i].y = table.probability();
        a[i].z = table.probability();
    }
    vector res(N, vector<ld>(N));
    rep(i, 0, N) rep(j, 0, N){
        if (i > j) res[i][j] = res[j][i];
        else if (i == j) res[i][j] = 0;
        else res[i][j] = dist(a[i], a[j]) + table.probability() * (ld)(0.2) - (ld)(0.1);
    }
    return res;
}

void solve();
// CITRUS CURIO CITY / FREDERIC
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int t = 1;
    // cin >> t;
    rep(i, 0, t) solve();
}

void solve(){
    const int local = false;
    int N;
    cin >> N;
    vector D(N, vector<ld>(N));
    if (local){
        int seed;
        cin >> seed;
        D = make(N, seed);
    }
    else{
        rep(i, 0, N) rep(j, 0, N) cin >> D[i][j];
    }
    auto calc_score = [&](vector<point> a) -> ld {
        ld sum = 0;
        rep(i, 0, N) rep(j, 0, i){
            ld tmp = dist(a[i], a[j]) - D[i][j];
            sum += tmp * tmp;
        }
        return sum;
    };
    auto real_score = [&](vector<point> a) -> ld {
        ld diff_max = 0;
        rep(i, 0, N) rep(j, 0, i){
            chmax(diff_max, abs(dist(a[i], a[j]) - D[i][j]));
        }
        return diff_max;
    };
    int st = clock();
    XorShift table;
    double start_temp = 0.001;
    double end_temp = 0.0001;
    ld delta = 100;
    double TL = 2500000;
    vector<point> ans(N);
    auto best = ans;
    ld best_score = real_score(ans);
    while (true){
        double now_time = clock() - st;
        if (now_time > TL) break;
        int ind = table.get(N);
        point ad;
        ad.x = table.probability() - 0.5;
        ad.y = table.probability() - 0.5;
        ad.z = table.probability() - 0.5;
        ld nor = hypot(ad.x, ad.y, ad.z);
        nor *= delta;
        ad.x /= nor, ad.y /= nor, ad.z /= nor;
        auto n_ans = ans;
        n_ans[ind] = add(n_ans[ind], ad);
        ld diff = calc_score(ans) - calc_score(n_ans);
        double temp = start_temp + (end_temp - start_temp) * now_time / TL;
        if (exp(diff / temp) > table.probability()){
            swap(n_ans, ans);
            if (chmin(best_score, real_score(ans))){
                best = ans;
            }
        }
    }
    ans = best;
    rep(i, 0, N){
        cout << fixed << setprecision(20) << ans[i].x << " " << ans[i].y << " " << ans[i].z << "\n";
    }
    if (local){

        cout << "diff max : " << real_score(ans) << "\n";
    }
}