Let's assume that we are given a matrix *b* of size *x* × *y*, let's determine the operation of mirroring matrix *b*. The mirroring of matrix *b* is a 2*x* × *y* matrix *c* which has the following properties:
 -  the upper half of matrix *c* (rows with numbers from 1 to *x*) exactly matches *b*; -  the lower half of matrix *c* (rows with numbers from *x* + 1 to 2*x*) is symmetric to the upper one; the symmetry line is the line that separates two halves (the line that goes in the middle, between rows *x* and *x* + 1). 
Sereja has an *n* × *m* matrix *a*. He wants to find such matrix *b*, that it can be transformed into matrix *a*, if we'll perform on it several (possibly zero) mirrorings. What minimum number of rows can such matrix contain?
The first line contains two integers, *n* and *m* (1 ≤ *n*, *m* ≤ 100). Each of the next *n* lines contains *m* integers — the elements of matrix *a*. The *i*-th line contains integers *a*<sub class="lower-index">*i*1</sub>, *a*<sub class="lower-index">*i*2</sub>, ..., *a*<sub class="lower-index">*im*</sub> (0 ≤ *a*<sub class="lower-index">*ij*</sub> ≤ 1) — the *i*-th row of the matrix *a*.
def inverte(a):
    tmp = ''
    
    for let in a:
        if let == '0':
            tmp += '1'
        else:
            tmp += '0'
    
    return tmp

linha = [int(i) for i in input().split()]
n = linha[0]
m = linha[1]

arr = []
for i in range(n):
    arr.append(''.join(input().split()))

def solve(x):
    c = 0
    tmp = []
    for i in range(0, n, x):
        if c % 2 == 0:
            tmp.append(arr[i:i+x])
        else:
            tmp.append([inverte(k) for k in arr[i:i+x]])
        c += 1
    
    for i in range(len(tmp)-1):
        if tmp[i] != tmp[i+1]:
            return False
        
    return True

ans = n
for i in range(1, n):
    if n%i == 0 and solve(i):
        ans = i
        break

print(ans)
		  			 			 	 	    	   	 	   	