import math

def Input():
    N = int(input())
    M = int(input())
    t = []
    global s
    global n
    s = 1
    n = 1
    for i in range(N):
        t += [list(map(int, input().split()))]
    Stage(t)

def EP1(m, a, b):
    for i in range(len(m[a])):
        m[b][i] += m[a][i]

def EP2(m, a, b):
    global s
    m[a], m[b] = m[b], m[a]
    s *= -1

def EP3(m, a, l, i):
    global s
    global n
    if i:
        for i in range(len(m[a])):
            m[a][i] *= l
        s *= l
    else:
        for i in range(len(m[a])):
            m[a][i] //= l
        n *= l

def NOK(a, b):
    n = a*b
    n //= math.gcd(a, b)
    return n

def SortM(m):
    Zstr = []
    N = len(m)
    for i in range(N):
        k = Leader(m, i)
        Zstr += [k]

    for i in range(N):
        for j in range(N-1):
            if Zstr[j] > Zstr[j + 1]:
                EP2(m, j, j + 1)
                Zstr[j], Zstr[j + 1] = Zstr[j + 1], Zstr[j]

    return Zstr

def PrintM(m):
    N = len(m)
    M = len(m[0])
    for i in range(N):
        print('|', end = ' ')
        for j in range(M):
            print(m[i][j], end = ' ')
        print('|')

def L(m, a):
    k = Leader(m, a)
    if k != len(m[a]) and m[a][k] < 0:
        EP3(m, a, -1, 1)

    l = max(m[a])
    if l == 0:
        l = 1
    for i in range(k, len(m[a])):
        if math.gcd(m[a][k], m[a][i]) < l and math.gcd(m[a][k], m[a][i]) != 0:
            l = math.gcd(m[a][k], m[a][i])
    EP3(m, a, l, 0)


def Simply(m):
    N = len(m)
    for i in range(N):
        L(m, i)
    SortM(m)

def Terminator(m, i, j):
    N = len(m)
    for k in range(i + 1, N):
        if m[k][j] != 0:
            l = NOK(m[k][j], m[i][j])
            b = 1 * (l // m[k][j])
            a = -1 * (l // m[i][j])
            EP3(m, k, b, 1)
            EP3(m, i, a, 1)
            EP1(m, i, k)
    Simply(m)


def Leader(m, a):
    N = len(m)
    M = len(m[a])
    k = 0
    j = 0
    while (j < M and m[a][j] == 0):
        k += 1
        j += 1
    return k

def Stage(m):
    N = len(m)
    M = len(m[0])
    Simply(m)
    for i in range(N):
        k = Leader(m, i)
        if k != M:
            Terminator(m, i, k)
    print()
    print('Ступенчатый вид:')
    PrintM(m)

    r = 0
    while r < N and Leader(m, r) != M:
        r += 1
    print()
    print('rk A = ', r)
    Det(m)

def Det(m):
    global s
    global n
    print()
    if len(m) != len(m[0]):
        print('Определителя не существует')
    else:
        k = 1
        for i in range(len(m)):
            k *= m[i][i]
        k *= n
        k //= s
        print('det(A) =', k)


Input()