#include <bits/stdc++.h>
#define nmax 102
#define infinity 2000000000
using namespace std;
ifstream fin ("royfloyd.in");
ofstream fout ("royfloyd.out");

struct graf{
  int destinatie, cost;
};

int n, m, distante[nmax][nmax], contor[nmax], nod_dijkstra, fr;
bool incoada[nmax], checked[nmax];

vector <graf> graphs[nmax];
queue <int> coada;

struct fun{
    bool operator()(int x, int y)
    {
        return distante[nod_dijkstra][x] > distante[nod_dijkstra][y];
    }
};

priority_queue <int, vector <int>, fun> prq;

void bellmanford()
{
    graf x;
    int i, j, nod;
    for(i = 1; i <= n; i++)
        coada.push(i), incoada[i] = 1;
    for(i = 1; i <= n; i++)
        x.cost = 0, x.destinatie = i, graphs[0].push_back(x);
    while(!coada.empty())
    {
        nod = coada.front();
        contor[nod]++;
        if(contor[nod] == n)
        {
            fout << "Ciclu negativ!";
            return;
        }
        for(j = 0; j < graphs[nod].size(); j++)
        {
            if (distante[0][graphs[nod][j].destinatie] > distante[0][nod] + graphs[nod][j].cost)
            {
                distante[0][graphs[nod][j].destinatie] = distante[0][nod] + graphs[nod][j].cost;
                if(!incoada[graphs[nod][j].destinatie])
                    coada.push(graphs[nod][j].destinatie), incoada[graphs[nod][j].destinatie] = 1;
            }
        }
        coada.pop();
        incoada[nod] = 0;
    }
}

void johnson()
{
    int i, j;
    for(i = 1; i <= n; i++)
        for (j = 0; j < graphs[i].size(); j++)
            graphs[i][j].cost = graphs[i][j].cost  + distante[0][i] - distante[0][graphs[i][j].destinatie];
}

void dijkstra(int nod)
{
    nod_dijkstra = nod;
    unsigned contor, marime;
    prq.push(nod);
    distante[nod][nod] = 0;
    while(!prq.empty())
    {
        fr = prq.top();
        prq.pop();
        marime = graphs[fr].size();
        checked[fr] = false;
        for(contor = 0; contor < marime; contor++)
            if(distante[nod][fr] + graphs[fr][contor].cost < distante[nod][graphs[fr][contor].destinatie])
            {
                distante[nod][graphs[fr][contor].destinatie] = distante[nod][fr] + graphs[fr][contor].cost;
                if(!checked[graphs[fr][contor].destinatie])
                    prq.push(graphs[fr][contor].destinatie), checked[graphs[fr][contor].destinatie] = true;
            }
    }

    for(int i = 0; i <= n; i++)
        checked[i] = 0;
}


int main()
{
    graf x;
    int i, j;
    fin >> n;
    for(i = 1; i <= n; i++)
    {
        for(j = 1; j <= n; j++)
        {
            fin >> x.cost;
            x.destinatie = j;
            if(x.cost != 0)
                graphs[i].push_back(x);
        }
    }
    bellmanford();
    johnson();
    for(i = 1; i <= n; i++)
        for(j = 1; j <= n; j++)
            distante[i][j] = infinity;

    for(i = 1; i <= n; i++)
        dijkstra(i);


    for(i = 1; i <= n; i++)
    {
        for(j = 1; j <= n; j++)
            fout << distante[i][j] - distante[0][i] + distante[0][j] << ' ';
        fout << endl;
    }

    return 0;
}