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 
from sys import stdin, stdout

class DFS_General:
    def __init__(self,matrix,n):
        self.n= n
        self.pi = [-1 for _ in range(0,n)]
        self.cycle = False
        self.vertex = []
        self.d = [-1 for _ in range(0,n)]
        self.color = [-1 for _ in range(0,n)]
        self.matrix = matrix
        self.V= -1
        self.cycle = False
    def DFS_visit(self, u):
        self.color[u]=0
        for v in range(0,self.n):
                if self.color[v]==-1 and self.matrix[u,v]==1:
                    self.pi[v]= u
                    self.DFS_visit(v)
                    if self.cycle:
                        self.vertex.append(v)
                        break
                elif self.color[v]==0 and self.V == -1 and not self.cycle and  self.matrix[u,v]==1:
                    self.V = v
                    self.cycle = True
                    break
        self.color[u]=1            

    def DFS(self):
        for i in range(0,self.n):
            if  self.color[i]==-1 and not self.cycle:
                self.DFS_visit(i)
                if self.cycle and self.V == i:  
                    self.vertex.append(self.V)
                    break
                  
    def Vertex(self):
        final = [-1 for _ in range(0,3)]
        change = False
        count = len(self.vertex)-1
        final[0]= self.vertex[count]
        count-=1
        final[1]= self.vertex[count]
        count -= 1
        while not change :
            if self.matrix[self.vertex[count],final[0]]== 1:
                final[2] = self.vertex[count]
                change = True
            else:
                final[1]= self.vertex[count]
                count-=1 
        for i in range(0,3):      
            final[i]+= 1
        return final    

n = int(stdin.readline())
matrix = [[] for _ in range(n)]
for i in range(n):
    matrix [i]= [int(x) for x in stdin.readline().split()]

DFS_ = DFS_General(matrix,n)
DFS_.DFS()
if DFS_.cycle: 
    cycle= DFS_.Vertex()
    stdout.write("v_1 = " + str(cycle[0]) + "  v_2 = " + str(cycle[1]) + "  v_3 = "  + str(cycle[2]) +  "\n")   
else:
    stdout.write(-1)


    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    