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 
##########################################################
####################### Quicksort ########################
##########################################################
def sort(array=[1,2,3], array_id=[1,2,3]):
	less = []
	equal = []
	greater = []
	less_id = []
	equal_id = []
	greater_id = []

	if len(array) > 1:
		pivot = array[0]
		i = 0
		for x in array:
			if x < pivot:
				less.append(x)
				less_id.append(array_id[i])
			if x == pivot:
				equal.append(x)
				equal_id.append(array_id[i])
			if x > pivot:
				greater.append(x)
				greater_id.append(array_id[i])
			i += 1
		# Return
		return sort(less, less_id)+ equal_id +sort(greater, greater_id)  # Join lists
	else:  # Hande the part at the end of the recursion - when you only have one element in your array
		return array_id
##########################################################


##########################################################
###################### Main program ######################
##########################################################
def main():
	n = input() # number of vertices
	ar = [] # store the input
	rank = [] # store the rank of each vertex
	rank_id = []
	skip = []
	count = 0
	for index in range(int(n)): # scan through the input
		line = input()
		nextvertex = list(line.strip()) # split the string to array
		ar.append(nextvertex) # store the input array
		outgoing = 0 # start counting the outgoing edges
		for i in nextvertex:
			outgoing += int(i)
		rank.append(outgoing)
		rank_id.append(count)
		skip.append(0)
		count += 1

	rank_id = sort(rank, rank_id) # the order of vertex which will be computed

	for src_id in rank_id:
		outvertex_id = 0
		for outvertex in ar[src_id]:
			if outvertex == '1':
				nextvertex_id = 0
				for nextvertex in ar[outvertex_id]:
					if skip[nextvertex_id] == 1: break 
					if nextvertex == '1':
						if ar[nextvertex_id][src_id] == '1':
							print (str(src_id+1) + " " + str(outvertex_id+1) + " " + str(nextvertex_id+1))
							return 0;
					nextvertex_id += 1
			outvertex_id += 1
		skip[src_id] = 1 # remove the useless vertex
	return -1 # if triangle not existed
##########################################################

if (main() == -1): print(-1)
