#include <cstring>

 #include <cstdio>

 #include <algorithm>

 #include <map>

 #include <cmath>

 using namespace std;

 const int MAXN = ;

 int n, p;

 struct Matrix {

     int a[MAXN][MAXN];

     int *operator[]( int idx ) {

         return a[idx];

     }

     const int *operator[]( int idx ) const {

         return a[idx];

     }

     bool operator<( const Matrix &rhs ) const { // 用于map

         for( int i = ; i < n; ++i )

             for( int j = ; j < n; ++j )

                 if( a[i][j] < rhs[i][j] ) return true;

                 else if( a[i][j] > rhs[i][j] ) return false;

         return false;

     }

     void unit() { // 填成n阶单位矩阵

         memset( a, , sizeof(a) );

         for( int i = ; i < n; ++i ) a[i][i] = ;

     }

     void clear() { // 填成全0

         memset( a, , sizeof(a) );

     }

 };

 Matrix A, B; // 题目中给定的A，B矩阵

 int pow_mod( int a, int b ) { // 整数快速幂

     int ans = ;

     while(b) {

         if( b& ) ans = ans * a % p;

         a = a * a % p;

         b >>= ;

     }

     return ans;

 }

 int inv( int a ) { // 整数求逆

     return pow_mod(a,p-);

 }

 void input_matrix( Matrix &A ) {

     for( int i = ; i < n; ++i )

         for( int j = ; j < n; ++j ) {

             scanf( "%d", &A[i][j] );

             A[i][j] %= p;

         }

 }

 void mul( const Matrix &A, const Matrix &B, Matrix &C ) { // 矩阵乘法，结果存入C

     Matrix tmp; tmp.clear();

     for( int i = ; i < n; ++i )

         for( int j = ; j < n; ++j )

             for( int k = ; k < n; ++k )

                 tmp[i][j] = (tmp[i][j] + A[i][k] * B[k][j] % p) % p;

     C = tmp;

 }

 void gauss_jordan( int A[MAXN][MAXN<<] ) { // 高斯约当消元求逆

     for( int i = ; i < n; ++i ) {

         int r;

         for( r = i; r < n; ++r )

             if( A[r][i] ) break;

         if( r != i )

             for( int j = i; j < (n<<); ++j )

                 swap( A[r][j], A[i][j] );

         int iv = inv( A[i][i] );

         for( int j = i; j < (n<<); ++j )

             A[i][j] = A[i][j] * iv % p;

         for( int j = ; j < n; ++j )

             if( j != i && A[j][i] ) {

                 int tmp = (p - A[j][i]) % p;

                 for( int k = i; k < (n<<); ++k )

                     A[j][k] = (A[j][k] + A[i][k] * tmp % p) % p;

             }

     }

 }

 void inv( const Matrix &A, Matrix &B ) { // 矩阵求逆，结果存入B

     int tmp[MAXN][MAXN<<] = {};

     for( int i = ; i < n; ++i )

         for( int j = ; j < n; ++j )

             tmp[i][j] = A[i][j];

     for( int i = ; i < n; ++i ) tmp[i][i+n] = ;

     gauss_jordan(tmp);

     for( int i = ; i < n; ++i )

         for( int j = ; j < n; ++j )

             B[i][j] = tmp[i][j+n];

 }

 map<Matrix,int> mp;

 int bsgs( Matrix A, Matrix B ) { // 大步小步算法

     int m = sqrt(p)+;

     Matrix E; E.unit();

     for( int i = ; i < m; ++i ) {

         if( !mp.count(E) ) mp[E] = i;

         mul(E,A,E);

     }

     inv(E,E);

     for( int i = ; i < p; i += m ) {

         if( mp.count(B) ) return i + mp[B];

         mul(B,E,B); // 注意矩阵乘法顺序

     }

     return -;

 }

 int main() {

     scanf( "%d%d", &n, &p );

     input_matrix(A), input_matrix(B);

     printf( "%d\n", bsgs(A,B) );

     return ;

 }