#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <set>
#include <vector>
#include <cstring>
#include <string>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <complex>
#include <map>
#include <queue>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef vector<pii> vii;
typedef vector<string> vs;

void out(vl v) {
    for (int i = 0; i < v.size(); ++i)
        cout << v[i] << ' ';
    cout << endl;
}

void out(vvl v) {
    for (int i = 0; i < v.size(); ++i)
        out(v[i]);
    cout << endl;
}

void outerr(vl v) {
    for (int i = 0; i < v.size(); ++i)
        cerr << v[i] << ' ';
    cerr << endl;
}

void outerr(vvl v) {
    for (int i = 0; i < v.size(); ++i)
        outerr(v[i]);
    cerr << endl;
}

vvl id (int n) {
    vvl v(n, vl(n));
    for (int i =0 ; i < n; ++i) v[i][i] = 1;
    return v;
}

void model(vvl & v, vl x, int inv) {
    if (x.size() == 2) {
        if (x[1] == -1) {
            for (int j = 0; j < v.size(); ++j)
                v[x[0]][j] *= -1;
            return;
        }
        model(v, {x[0], x[1], 1}, 0);
        model(v, {x[1], x[0], -1}, 0);
        model(v, {x[0], x[1], 1}, 0);
        model(v, {x[0], -1}, 0);
        return;
    }
    if (inv) {
        x[2] *= -1;
    }
    for (int j = 0; j < v.size(); ++j)
        v[x[1]][j] += v[x[0]][j]*x[2];
}

vvl tr(vvl v) {
    int n = v.size();
    for (int i = 0; i < n; ++i) for (int j = 0; j < i; ++j) {
        swap(v[i][j], v[j][i]);
    }
    return v;
}

vvl mul(vvl x, vvl y) {
    int n = x.size();
    vvl res(n, vl(n));
    for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) {
        for (int l = 0; l < n; ++l) {
            //if (abs(y[l][j])) assert(abs(x[i][l]) < 4e18/abs(y[l][j]));
            res[i][j] += x[i][l]*y[l][j];
            //assert(abs(res[i][j]) < 4e18);
        }
    }
    return res;
}

int main() {
    freopen("higher.in", "r", stdin);
    freopen("higher.out", "w", stdout);
    int n = 4;
    for (int mask = 0; mask < 100000; ++mask) {
        int m = mask;
    }while (cin >> n) {
        if (n == 0) break;
        vvl a(n, vl(n));
        for (int i = 0; i < n; ++i) for (int j =0 ; j < n; ++j) {
            //a[i][j] = m % 4 - 2;
            //m /= 4;
            cin >> a[i][j];
        }
        vvl a0 = a;
        int b = 0;
        vvl row, col;
        while (b < n) {
            //outerr (a);
            //			out (a);
            ll mi=2.1e18;
            int r,c;
            for (int i = b; i < n; ++i) for (int j = b; j < n; ++j) {
                if (a[i][j] && abs(a[i][j]) < mi) {
                    r=i; c=j;
                    mi = abs(a[i][j]);
                }
            }
            if (mi > 2e18) break;
            int r1 = -1, c1 = -1;
            ll m1 = mi;
            for (int i = b; i < n; ++i) for (int j = b; j < n; ++j) if (abs(a[i][j])) {
                for (int i1 = b; i1 < n; ++i1) if (i1 != i && abs(a[i1][j]) % abs(a[i][j])) {
                    if (abs(a[i1][j]) % abs(a[i][j]) < m1) {
                        m1 = abs(a[i1][j]) % abs(a[i][j]);
                        r = i;
                        r1 = i1; 
                        c = c1 = j;
                    }
                }
                for (int j1 = b; j1 < n; ++j1) if (j1 != j && abs(a[i][j1]) % abs(a[i][j])) {
                    if (abs(a[i][j1]) % abs(a[i][j]) < m1) {
                        m1 = abs(a[i][j1]) % abs(a[i][j]);
                        r = r1 = i;
                        c = j;
                        c1 = j1;
                    }
                }
            }
            if (m1 == mi) {
                for (int i = b; i < n; ++i) for (int j = b; j < n; ++j) if (abs(a[i][j])) {
                    for (int i1 = b; i1 < n; ++i1) for (int j1 = b; j1 < n; ++j1) if (abs(a[i1][j1]) % abs(a[i][j])) {
                        if (abs(a[i1][j1]) % abs(a[i][j]) < m1) {
                            m1 = abs(a[i1][j1]) % abs(a[i][j]);
                            r = i;
                            r1 = i1;
                            c = j;
                            c1 = j1;
                        }
                    }
                }
            }
            if (r1 == -1) {
                if (b != r) {
                    row.push_back({b, r});
                    model(a, row.back(), 0);
                    //a[b].swap(a[r]);
                }
                if (b != c) {
                    col.push_back({b, c});
                    for (int i = 0; i < n; ++i)
                        swap(a[i][b], a[i][c]);
                }
                for (int i = b + 1; i < n; ++i) {
                    row.push_back({b, i, -a[i][b] / a[b][b]});
                    model(a, row.back(), 0);
                    assert(a[i][b] == 0);
                }
                for (int i = b + 1; i < n; ++i) {
                    ll x = -a[b][i] / a[b][b];
                    col.push_back({b, i, x});
                    for (int j = 0; j < n; ++j) {
                        a[j][i] += a[j][b]*x;
                    }
                    assert(a[b][i] == 0);
                }
                if (a[b][b] < 0) {
                    row.push_back({b, -1});
                    a[b][b] *= -1;
                }
                ++b;	
            } else {
                assert(abs(a[r1][c1]) % abs(a[r][c]) == m1);
                if (r != r1 && c != c1) {
                    assert(a[r1][c] % abs(a[r][c]) == 0);
                    row.push_back({r, r1, -a[r1][c] / a[r][c] + 1});
                    r = r1;
                    model(a, row.back(), 0);
                }
                if (a[r][c] < 0) {
                    row.push_back({r, -1});
                    model(a, row.back(), 0);
                }
                if (a[r1][c1] < 0) {
                    row.push_back({r1, -1});
                    model(a, row.back(), 0);
                }
                if (r == r1) {
                    ll x = -a[r][c1]/a[r][c]; //??
                    col.push_back({c, c1, x});
                    for (int i = 0; i < n; ++i)
                        a[i][c1] += a[i][c]*x;
                } else {
                    assert(c == c1);
                    ll x = -a[r1][c]/a[r][c]; //??
                    row.push_back({r, r1, x});
                    for (int i = 0; i < n; ++i)
                        a[r1][i] += a[r][i]*x;
                }
                //assert(abs(a[r1][c1]) == m1);
            }
        }
        vvl L = id(n), L1 = id(n), R = id(n), R1 = id(n);
        vvl test = a0;
        for (int i = 0; i < row.size(); ++i) {
            model(L1, row[row.size()-i-1], 1);
            model(L, row[i], 0);
            model(test, row[i], 0);
        }
        assert(test == mul(L, a0));
        for (int i = 0; i < col.size(); ++i) {
            model(R, col[i], 0);
            model(R1, col[col.size()-i-1], 1);
        }
        R = tr(R);
        R1 = tr(R1);
        out(L);
        out(L1);
        out(R);
        out(R1);
        assert(mul(L, L1) == id(n));
        assert(mul(R, R1) == id(n));
        assert(mul(mul(L, a0),R) == a);
        for (int i = 0; i < n; ++i) for (int j = 0; j < n; ++j) if (i != j)
            assert(a[i][j] == 0);
        for (int i = 0; i+1 < n; ++i) {
            assert(a[i][i] == 0 || a[i+1][i+1] % a[i][i] == 0);
            assert(a[i][i] || a[i+1][i+1] == 0);
        }
    }
    return 0;
}