#include <fstream>
#include <iostream>
#include <limits>
#include <vector>

using namespace std;

class graph {
  public:
    explicit graph(int _size)
      : size(_size),
      cost(_size, vector<int>(_size)),
      adjacency(_size, vector<bool>(_size, false)) {}

    void add_edge(int src, int dst, int cost_) {
      if (cost_ != 0)
        adjacency[src][dst] = true;
      cost[src][dst] = cost_;
    }

    vector<vector<int>> roy_floyd() {
      vector<vector<int>> result(size, vector<int>(size));

      for (int i = 0; i < size; ++i)
        for (int j = 0; j < size; ++j) {
          result[i][j] = cost[i][j];
          if (i != j && result[i][j] == 0)
            result[i][j] = numeric_limits<int>::max() / 2 - 1;
        }

      for (int k = 0; k < size; ++k) {
        for (int i = 0; i < size; ++i) {
          for (int j = 0; j < size; ++j) {
            result[i][j] = min(result[i][j],
                result[i][k] + result[k][j]);
          }
        }
      }

      return result;
    }

  private:
    int size;
    vector<vector<int>> cost;
    vector<vector<bool>> adjacency;
};

int main()
{
  ifstream fin("royfloyd.in");
  ofstream fout("royfloyd.out");

  int N;
  fin >> N;

  graph g(N);
  for (auto i = 0; i < N; ++i)
    for (auto j = 0; j < N; ++j) {
      int cost;
      fin >> cost;
      g.add_edge(i, j, cost);
    }

  vector<vector<int>> result = g.roy_floyd();
  for (auto row : result) {
    for (auto elem : row)
      fout << elem << " ";
    fout << "\n";
  }

  return 0;
}