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

class graph {
 public:
    explicit graph(int _size)
        : size(_size), 
          cost_matrix(_size, std::vector<int>(_size)),
          adjacency_matrix(_size, std::vector<bool>(_size, false)) {}

    void add_edge(int src, int dst, int cost) {
        adjacency_matrix[src][dst] = (cost != 0);
        cost_matrix[src][dst] = cost;
    }

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

        std::cout << size << "\n";
        for (auto i = 0; i < size; ++i)
            for (auto j = 0; j < size; ++j)
                result[i][j] = cost_matrix[i][j];

        for (auto k = 0; k < size; ++k) {
            for (auto i = 0; i < size; ++i) {
                for (auto j = 0; j < size; ++j) {
                    if (!adjacency_matrix[i][k] || 
                        !adjacency_matrix[k][j] || i == j)
                        continue;

                    if (!adjacency_matrix[i][j]) {
                        result[i][j] = result[i][k] + result[k][j];
                    } else {
                        result[i][j] = std::min(result[i][j], 
                                        result[i][k] + result[k][j]);
                    }
                }
            }
        }

        return result;
    }

 private:
    int size;
    std::vector<std::vector<int>> cost_matrix;
    std::vector<std::vector<bool>> adjacency_matrix;
};

int main()
{
    std::ifstream fin("royfloyd.in");
    std::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);
        }

    std::vector<std::vector<int>> result = g.roy_floyd();
    for (auto i = 0; i < result.size(); ++i) {
        for (auto j = 0; j < result[i].size(); ++j)
            fout << result[i][j] << " ";
        fout << "\n";
    }

    return 0;
}