#include <algorithm>
#include <vector>
#include <queue>
#include <fstream>

#define INF ((1 << 30) - 1)
typedef std::pair<int, int> edge;

std::vector<int> dijkstra(const std::vector<std::vector<edge> >& graph, int node) {
	int n = graph.size() / 2 - 1;
	std::priority_queue<edge, std::vector<edge>, std::greater<edge> > prio_q;
	std::vector<int> dist(n, INF);

	dist[node - 1] = 0;
	prio_q.push(std::make_pair(0, node));

	while (!prio_q.empty()) {
		int u = prio_q.top().second;
		prio_q.pop();

		if (graph[u].size() != 0) {
			for (unsigned int i = 0; i < graph[u].size(); ++i) {
				int v = graph[u][i].first;
				int weight = graph[u][i].second;
				if (dist[v - 1] > dist[u - 1] + weight) {
					dist[v - 1] = dist[u - 1] + weight;

					prio_q.push(std::make_pair(dist[v - 1], v));
				}
			}
		}
	}

	for (unsigned int i = 0; i < dist.size(); ++i) {
		if (dist[i] == INF) {
			dist[i] = -1;
		}
	}
	
	return dist;
}

std::vector<std::vector<int> > shortest_path_all(const std::vector<std::vector<edge> >& graph) {
	int n = graph.size() / 2 - 1;

	std::vector<std::vector<int> > costs;

	for (int i = 1; i <= n; ++i) {
		costs.push_back(dijkstra(graph, i));
	}

	return costs;
}

int main() {
    int nNodes, i, j, cost;

    std::ifstream in("royfloyd.in");
    std::ofstream out("royfloyd.out");

    in >> nNodes;

	std::vector<std::vector<edge> > graph(nNodes + 1);

	for (int i = 0; i <= nNodes; ++i) {
		graph.push_back(std::vector<edge>());
	}

    for (i = 1; i <= nNodes; ++i) {
        for (j = 1; j <= nNodes; ++j) {
            in >> cost;

            if (cost) {
                graph[i].push_back(std::make_pair(j, cost));
            }
        }
    }

	std::vector<std::vector<int> > costs = shortest_path_all(graph);

    for (i = 0; i < nNodes; ++i) {
        for (j = 0; j < nNodes; ++j) {
            if (costs[i][j] == INF) {
                costs[i][j] = 0;
            }

            out << costs[i][j] << " ";
        }

        out << "\n";
    }

    return 0;
}