#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

#define SIZE 10000

/* Eine First-In First-Out Queue fuer entdeckten Knoten. */
struct fifo_queue {
	int values[SIZE];
	int front, tail;
};

/* Queue Initialisieren */
void fifo_init (struct fifo_queue * q)
{
	q->front = q->tail = 0;
}

/* Liefert TRUE, wenn die queue leer ist. */
int fifo_empty (struct fifo_queue * q)
{
	return q->front == q->tail;
}

/* Ein Element hinten an die queue anhaengen. */
void fifo_push (struct fifo_queue * q, int val)
{
	q->values[q->tail] = val;
	q->tail = (q->tail+1) % SIZE;
	assert (q->tail != q->front);
}

/* Ein Element vorne aus der queue herausnehmen. */
int fifo_pop (struct fifo_queue * q)
{
	assert (q->front != q->tail);
	int ret = q->values[q->front];
	q->front = (q->front+1) % SIZE;
	return ret;
}

/* Breitensuche durchfuehren. Arrays werden per Referenz uebergeben!
   Parameter:
     - N: Anzahl der Knoten im Graph
     - g: Die Nachbarschaftsmatrix
     - dist: Hier wird fuer jeden Knoten der Abstand von 0 zurueckgeliefert
     - src: Hier wird fuer jeden Knoten zurueckgeliefert, von welchem Knoten
            aus er entdeckt wurde.
 */
void BFS (int N, int g[SIZE][SIZE], int dist[SIZE], int src[SIZE])
{
	int i;
	struct fifo_queue fifo;
	assert (N <= SIZE);
	assert (0 < N);

	/* Fifo, dist und src initialisieren. */
	fifo_init (&fifo);
	for (i=0; i<N; ++i) {
		dist[i] = -1;
		src[i] = -1;
	}
	/* Abstand fuer Knoten 0 festlegen und Knoten 0 in die Queue. */
	fifo_push (&fifo, 0);
	dist[0] = 0;
	/* Solange es noch Knoten zu waehlen gibt ... */
	while (!fifo_empty (&fifo)) {
		int t = fifo_pop (&fifo);	/* ... einen auswaehlen ... */
		assert (dist[t] >= 0);
		/* ... seine Nachbarn durchgehen und ... */
		for (i=0; i<N; ++i) {
			if (g[t][i] != 1)
				continue;
			if (dist[i] >= 0)
				continue;
			/* ... die noch nicht entdeckten mit Abstand versehen
			 * und in die fifo stecken. */
			dist[i] = dist[t]+1;
			src[i] = t;
			fifo_push (&fifo, i);
		}
	}
}

int g[SIZE][SIZE];
int dist[SIZE];

int main ()
{
	char buf[SIZE+1];
	int i, j, N;
	int src[SIZE];
	int path[SIZE];
	/* Groesse des Graph ... */
	if (scanf ("%d\n", &N) != 1) {
		fprintf (stderr, "Bad Input\n");
		return 1;
	}
	assert (N >=2 && N <= SIZE);
	/* ... und den Graph selbst einlesen. */
	for (i=0; i<N; ++i) {
		scanf ("%s", buf);
		assert (strlen (buf) == N);
		assert (buf[i] == '0');
		for (j=0; j<N; ++j) {
			switch (buf[j]) {
			case '0':
				g[i][j] = 0;
				break;
			case '1':
				g[i][j] = 1;
				break;
			default:
				assert (0);
			}
		}
	}
	/* Breitensuche durchfuehren. */
	BFS(N, g, dist, src);
	/* Fuer jeden Knoten den Weg bestimmen. */
	for (i=0; i<N; ++i) {
		int plen = 0;
		int cur;
		printf ("Dist from 0 to %d: %d", i, dist[i]);
		if (dist[i] == -1) {
			printf ("\n");
			continue;
		}
		cur = i;
		while (cur >= 0) {
			path[plen++] = cur;
			cur = src[cur];
		}
		printf ("  Path:");
		assert (plen == dist[i]+1);
		for (plen--; plen >=0; plen--) {
			printf (" %d", path[plen]);
		}
		printf ("\n");
	}
	return 0;
}