#include <iostream>
#include <vector>
#include <climits>

#define INFINIT 1000000 // O valoare mare folosită pentru a reprezenta infinitul

using namespace std;

class Graf {
private:
    int nrNoduri; // Numărul de noduri din graf
public:
    explicit Graf(int nrNoduri);

    vector<vector<int>> floydWarshall(vector<vector<int>> &matriceCosturi);
};

// Constructor pentru inițializarea grafului
Graf::Graf(int nrNoduri) {
    this->nrNoduri = nrNoduri;
}

// Implementarea algoritmului Floyd-Warshall
vector<vector<int>> Graf::floydWarshall(vector<vector<int>> &matriceCosturi) {
    // Copiem matricea costurilor inițiale
    vector<vector<int>> distante = matriceCosturi;

    // Pasul 1: Setăm distanțele pentru cazurile unde nu există muchii directe
    for (int i = 0; i < nrNoduri; i++) {
        for (int j = 0; j < nrNoduri; j++) {
            if (i != j && distante[i][j] == 0) {
                distante[i][j] = INFINIT; // Nu există drum direct
            }
        }
    }

    // Pasul 2: Aplicația algoritmului
    for (int k = 0; k < nrNoduri; k++) {          // Nodul intermediar
        for (int i = 0; i < nrNoduri; i++) {      // Nodul sursă
            for (int j = 0; j < nrNoduri; j++) {  // Nodul destinație
                if (distante[i][k] < INFINIT && distante[k][j] < INFINIT) {
                    // Actualizăm distanța minimă folosind nodul intermediar `k`
                    distante[i][j] = min(distante[i][j], distante[i][k] + distante[k][j]);
                }
            }
        }
    }

    // Returnăm matricea distanțelor minime
    return distante;
}

int main() {
    int n;
    cin >> n; // Citim numărul de noduri

    vector<vector<int>> matriceCosturi(n, vector<int>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> matriceCosturi[i][j]; // Citim matricea costurilor
        }
    }

    Graf g(n); // Inițializăm graful cu `n` noduri

    // Aplicăm algoritmul Floyd-Warshall
    vector<vector<int>> distante = g.floydWarshall(matriceCosturi);

    // Afișăm matricea distanțelor minime
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (distante[i][j] >= INFINIT) {
                cout << "0 "; // Nu există drum
            } else {
                cout << distante[i][j] << " ";
            }
        }
        cout << endl;
    }

    return 0;
}