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 arr_2d(n):
    return [[int(x) for x in stdin.readline().split()] for i in range(n)]


def factorize(n):  # o(sqr(n))
    c, ans = 1, []
    while (c * c < n):
        if n % c == 0:
            ans.extend([c, n // c])
        c += 1

    if c * c == n:
        ans.append(c)
    return sorted(ans)


from sys import stdin

n, m = map(int, input().split())
mat, div = arr_2d(n), factorize(n)

if n & 1:
    print(n)
else:
    arr = []
    for i, j in enumerate(div):
        arr.append(mat[i])
        c = 1
        for k in range(j, n + 1, j):
            if c & 1 and arr == list(reversed(mat[k:k + j])) or c % 2 == 0 and mat[k:k + j]:
                c += 1
            else:
                break
        if c == n // j:
            exit(print(j))
