A tournament is a directed graph without self-loops in which every pair of vertexes is connected by exactly one directed edge. That is, for any two vertexes *u* and *v* (*u* ≠ *v*) exists either an edge going from *u* to *v*, or an edge from *v* to *u*.

You are given a tournament consisting of *n* vertexes. Your task is to find there a cycle of length three.
The first line contains an integer *n* (1 ≤ *n* ≤ 5000). Next *n* lines contain the adjacency matrix *A* of the graph (without spaces). *A*<sub class="lower-index">*i*, *j*</sub> = 1 if the graph has an edge going from vertex *i* to vertex *j*, otherwise *A*<sub class="lower-index">*i*, *j*</sub> = 0. *A*<sub class="lower-index">*i*, *j*</sub> stands for the *j*-th character in the *i*-th line.

It is guaranteed that the given graph is a tournament, that is, *A*<sub class="lower-index">*i*, *i*</sub> = 0, *A*<sub class="lower-index">*i*, *j*</sub> ≠ *A*<sub class="lower-index">*j*, *i*</sub> (1 ≤ *i*, *j* ≤ *n*, *i* ≠ *j*).
5
00100
10000
01001
11101
11000
1 3 2 
5
01111
00000
01000
01100
01110
-1
5
01000
00101
10010
11001
10100
1 2 3 
5
00110
10110
00011
00000
11010
1 3 5 
10
0011000010
1011001101
0000101100
0010101010
1100000100
1111101100
1000100000
1001001011
0110111001
1011111000
1 3 5 
10
0111001000
0011111000
0000110110
0010101110
1000011001
1001000010
0010010101
1100110000
1100101100
1111010110
1 3 5 
10
0101111011
0001111111
1100011110
0010011000
0011000110
0000101011
0000100000
1001011011
0001001000
0011101010
1 4 3 
10
0000010011
1001001111
1100001110
1010010011
1111011000
0110000001
1001010100
1001110000
0000111101
0010101100
1 6 2 
10
0000000000
1001100111
1101101111
1000000011
1001000111
1111101111
1101100111
1001000011
1000000001
1000000000
-1
1
0
-1
2
00
10
-1
3
001
100
010
1 3 2 
3
010
001
100
1 2 3 
2
01
00
-1
3
011
000
010
-1
4
0000
1010
1001
1100
2 3 4 
5
01111
00111
00010
00001
00100
3 4 5 

def sefr_list(dic, matrix):
	#peida krdne unayi ke 0 hastn hmshun va negah dashtnshun tu ye list
	totally_sefr_list = []
	for i in range(0, matrix):
		counter=0
		for j in range(0, matrix):
			if dic[i][j]==0:
				counter+=1
		if counter==matrix:
			totally_sefr_list.append(i)
	return totally_sefr_list
	



def sefr_kon(totally_sefr_list, dic, matrix):
	#khane hayi ke 0 budand ro shomareye khane ash ra sefr konim dar baqie satr ha (az 1 be 0)
	# not ye chizi mige ke tush khalie ya na - age khali bashe=> if not a: print("List is empty")
	#age list khali nabashe inkaro kon:
	shomare_satre_khali = totally_sefr_list[0]
	del totally_sefr_list[0]

	while(True):
		for i in range(0, matrix):
			dic[i][shomare_satre_khali] = 0

		try:
			shomare_satre_khali = totally_sefr_list[0]
			del totally_sefr_list[0]
		except:
			break
	return dic




dic = {}
matrix = int(input())

for i in range(0,matrix):
	dic[i] = []
	satr = str(input())
	for j in range(0, matrix):
		dic[i].append(int(satr[j]))


#print(dic)


sharte_menhaye_yek = []
for i in range(0, matrix):
	sharte_menhaye_yek.append(i)






# func1
totally_sefr_list = sefr_list(dic, matrix)
#print (totally_sefr_list)

#func2

while(not (not totally_sefr_list)):
	dic = sefr_kon(totally_sefr_list, dic, matrix)
	#print(dic)
	totally_sefr_list = sefr_list(dic, matrix)

	if totally_sefr_list == sharte_menhaye_yek:
		print(-1)
		break

#print(dic)



# yek ha kuduman
yeks_list = []
for i in range(0,matrix):
	for j in range(0, matrix):
		if dic[i][j] == 0:
			pass
		else:
			#print(i,j)
			yeks_list.append(i)
			yeks_list.append(j)
#print(yeks_list)





found = False

length = len(yeks_list)
counter = 0
while(counter<length):

	if found == True:
		break


	#avali
	a1 = yeks_list[counter]
	#dovomi
	b1 = yeks_list[counter+1]

	counter2 = 0
	while(counter2<length):

		if found == True:
			break

		#sevomi
		a2 = yeks_list[counter2]
		#charomi
		b2 = yeks_list[counter2+1]

		counter3 = 0
		while(counter3<length):

			if found == True:
				break


			#panjomi
			a3 =  yeks_list[counter3]
			#shishomi
			b3 = yeks_list[counter3+1]


			if b1 == a2:
				if b2 == a3:
					if b3 == a1:
						print(a1+1,a2+1,a3+1)
						found = True
						break


			counter3+=2
		counter2+=2
	counter+=2

         	  			 			 		  				