#include <bits/stdc++.h>

using namespace std ;
#define int long long

const int N = 6e5 + 5 , mod = 998244353 , G = 3 ; 

namespace BINOM {
    int inv[N] , ifac[N] , fac[N] ;
    int init(int n = N) {
        inv[1] = fac[0] = ifac[0] = 1 ; 
        for (int i = 2 ; i < n ; ++ i) inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod ; 
        for (int i = 1 ; i < n ; ++ i) {
            fac[i] = 1ll * fac[i - 1] * i % mod ; 
            ifac[i] = 1ll * ifac[i - 1] * inv[i] % mod ; 
        }
        return 0 ; 
    }int get_binom = init() ;
    int C(int n , int m) {
        if (n < m || m < 0) return 0 ; 
        return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod ; 
    }
} 
using namespace BINOM ; 

int qmi(int a , int b = mod - 2) {
    int res = 1; a %= mod;
    while (b) {
        if (b & 1) res = (long long)res * a % mod;
        a = (long long)a * a % mod , b >>= 1;
    }
    return res;
}

inline void Add(int &x, int y) {
	x += y;
	if(x >= mod) x -= mod;
}
inline void Dec(int &x, int y) {
	x -= y;
	if(x < 0) x += mod;
}
inline int add(int x, int y) {
	x += y;
	if(x >= mod) x -= mod;
	return x;
}
inline int dec(int x, int y) {
	x -= y;
	if(x < 0) x += mod;
	return x;
}

namespace POLY {
    #define L(i, j, k) for(int i = (j); i <= (k); ++i)
    #define R(i, j, k) for(int i = (j); i >= (k); --i)
    #define V (*this)
    #define SZ() ((int) size())
    #define sz(a) ((int) a.size())
    #define vi vector < int >
    using ll = long long ;

    const int MOD = mod , inv2 = (MOD + 1) / 2 , _G = G ;  
    int rt[N << 1], Lim;
    int extend(int n) { return 1 << (__lg(n - 1) + 1) ; }
    int Pinit(int x) {
        for(Lim = 1; Lim < x; Lim <<= 1) ;
        for(int i = 1; i < Lim; i <<= 1) {
            int sG = qmi (_G, (MOD - 1) / (i << 1));
            rt[i] = 1;
            L(j, i + 1, i * 2 - 1) rt[j] = (ll) rt[j - 1] * sG % MOD;
        }
        return 0 ;
    }
    static int __POLY_INIT = Pinit(extend(N)) ;
    struct poly : public vector<int> {
        poly() : vi(){}
        poly(int n , int v = 0) : vi(n , v){}
        poly(vi t) : vi(t){}
        poly(initializer_list<int> li) : vi(li) {}
        int v(int i) { return i < 0 || i >= (int)size() ? 0 : V[i]; }
        void init(int n = 0) { vi(n).swap(V); }
        void clear() { init(0) ; }
        inline void dif() {
            int n = size() ; 
            for (int l = n >> 1; l >= 1; l >>= 1) 
                for(int j = 0; j < n; j += l << 1) 
                    for(int k = 0, *w = rt + l; k < l; k++, w++) {
                        int x = V[j + k], y = V[j + k + l];
                        V[j + k] = add(x, y);
                        V[j + k + l] = (ll) * w * dec(x, y) % MOD;
                    }
        }
        void dit () {
            int n = size() ; 
            for(int i = 2; i <= n; i <<= 1) 
                for(int j = 0, l = (i >> 1); j < n; j += i) 
                    for(int k = 0, *w = rt + l; k < l; k++, w++) {
                        int pa = V[j + k], pb = (ll) V[j + k + l] * *w % MOD;
                        V[j + k] = add(pa, pb), V[j + k + l] = dec(pa, pb);
                    }
            reverse(begin() + 1, end());
            for(int i = 0, iv = qmi(n); i < n; i++) V[i] = (ll) V[i] * iv % MOD;
        } 
        void trim() { while (!empty() && !back()) pop_back() ; }
        friend poly operator * (poly aa, poly bb) {
            if(!sz(aa) || !sz(bb)) return {};
            // return poly(MTT::conv(aa , bb , MOD));
            int all = sz(aa) + sz(bb) - 1 , lim = extend(all);
            aa.resize(lim), bb.resize(lim), aa.dif(), bb.dif();
            L(i, 0, lim - 1) aa[i] = (ll) aa[i] * bb[i] % MOD;
            aa.dit(), aa.resize(all);
            return aa;
        }
        poly Inv() {
            assert(empty() || V[0]);
            poly f, g , res = {qmi(V[0])} ;
            for(int m = 1, pn; m < SZ(); m <<= 1) {
                pn = m << 1, f = res, g.resize(pn), f.resize(pn);
                for(int i = 0; i < pn; i++) g[i] = v(i) ; 
                g *= f ; for(int i = 0; i < m; i++) g[i] = 0;
                g *= f , res.resize(pn);
                for(int i = m; i < min(pn, SZ()); i++) 
                    res[i] = (MOD - g[i]) % MOD;
            }
            return res.resize(SZ()) , res ;
        }
        poly operator << (int x) {
            poly zm (size() + x);
            L(i, 0, (int)size() - 1) zm[i + x] = V[i];
            return zm;
        }
        poly operator >> (int x) {
            if (x >= (int)size()) return poly();
            poly zm (size() - x);
            L(i, x , (int)size() - 1) zm[i - x] = V[i];
            return zm;
        }
        poly shift(ll k) {
            poly g = V ; 
            if (k > 0) {
                for (int i = SZ() - 1 ; i >= k ; -- i) g[i] = g[i - k] ;
                for (ll i = min((ll)SZ(), k) - 1; i >= 0 ; -- i) g[i] = 0 ; 
            }
            else if (k < 0) {
                k = -k ;
                for (int i = 0 ; i + k < SZ() ; ++ i) g[i] = g[i + k] ;
                for (ll i = max((ll)SZ() - k , 0ll) ; i < SZ() ; ++ i) g[i] = 0;
            }
            return g ;
        }
        friend pair<poly , poly> div (poly aa, poly bb) { //商,余
            aa.trim() , bb.trim();
            int n = aa.size() , m = bb.size() ;
            if (n < m) return {poly() , aa} ; 
            poly tb = bb ;
            aa.Rev() , bb.Rev() , bb.resize(n - m + 1) , bb = bb.Inv() ;
            poly cc = aa * bb ; cc.resize(n - m + 1) ; 
            cc.Rev() , aa.Rev() ; 
            poly dd = aa - tb * cc ; dd.resize(m - 1) , dd.trim() ;
            return {cc , dd} ; 
        }
        friend poly operator + (poly aa, poly bb) {
            poly res(max(sz(aa), sz(bb)));
            L(i, 0, sz(res) - 1) res[i] = add(aa.v(i), bb.v(i));
            return poly(res);
        }
        friend poly operator - (poly aa, poly bb) {
            poly res(max(sz(aa), sz(bb)));
            L(i, 0, sz(res) - 1) res[i] = dec(aa.v(i), bb.v(i));
            return poly(res);
        }
        friend poly operator * (poly aa, int bb) {
            poly res(sz(aa));
            L(i, 0, sz(aa) - 1) res[i] = (ll) aa[i] * bb % MOD;
            return res;
        }
        friend poly operator / (poly aa, poly bb) { return div(aa , bb).first ; }
        friend poly operator % (poly aa, poly bb) { return div(aa , bb).second ; }
        poly & operator += (poly o) {
            resize(max(SZ(), sz(o)));
            L(i, 0, SZ() - 1) (V[i] += o.v(i)) %= MOD;
            return V ;
        }
        poly & operator -= (poly o) {
            resize(max(SZ(), sz(o)));
            L(i, 0, SZ() - 1) (V[i] += MOD - o.v(i)) %= MOD;
            return V;
        }
        poly & operator *= (poly o) { return V = V * o; }
        poly & operator /= (poly o) { return V = V / o; }
        poly & operator %= (poly o) { return V = V % o; }
        poly Integ() {
            if(!SZ()) return poly();
            poly res(SZ() + 1);
            L(i, 1, SZ()) res[i] = (ll) V[i - 1] * inv[i] % MOD;
            return res;
        }
        poly Deriv() {
            if(!SZ()) return poly();
            poly res(SZ() - 1); 
            L(i, 1, SZ() - 1) res[i - 1] = (ll) V[i] * i % MOD;
            return res;
        }
        poly Ln() { // a[0] = 1
            poly g = (V.Inv() * V.Deriv()).Integ();
            return g.resize(SZ()), g;
        }
        poly Exp() { // a[0] = 0
            poly f , res = {1} ; 
            for(int m = 1, pn; m < SZ(); m <<= 1) {
                pn = min(m << 1, SZ()), f.resize(pn), res.resize(pn);
                for(int i = 0; i < pn; i++) f[i] = v(i);
                f -= res.Ln(), (f[0] += 1) %= MOD, res *= f, res.resize(pn); 
            }
            return res.resize(SZ()), res;
        }
        poly qpow(int x) {
            poly g(SZ()) , r = V; g[0] = 1 ; 
            for (;x;x >>= 1, r = r * r, r.resize(SZ())) 
                if (x & 1) g *= r , g.resize(SZ());
            return g; 
        }
        poly pow(int x, int rx = -1) { // x : the power % MOD; rx : the power % (MOD - 1)
            if(rx == -1) rx = x;
            int cnt = 0 , n = SZ(); 
            while (V[cnt] == 0 && cnt < n) ++ cnt;
            poly res = V >> cnt ; 
            int c = res[0], w = qmi(res[0]);
            res = (res * w).Ln();
            res = (res * x).Exp() ;
            // cout << c << ' ' << rx << ' ' << ' ' << (ll)c * c % mod << ' ' << qmi(c , rx) << '\n' ;
            res = res * qmi(c , rx);
            // if ((ll)cnt * x > n) L(i, 0, n - 1) res[i] = 0;
            // else if(cnt) {
            //     R(i, n - cnt * x - 1, 0) res[i + cnt * x] = res[i];
            //     L(i, 0, cnt * x - 1) res[i] = 0; 
            // }
            res = res.shift((ll) cnt * x);
            return res.resize(n) , res;
        }
        poly sqrt(int Rt = 1) { // a[0] = 1
            poly res = {Rt} , f; int n = SZ() ; 
            for(int m = 1, pn; m < n; m <<= 1) {
                pn = min(m << 1, n), f.resize(pn);
                for(int i = 0; i < pn; i++) f[i] = v(i);
                f += res * res, f.resize(pn), res.resize(pn), res = f * res.Inv(), res.resize(pn);
                for(int i = 0; i < pn; i++) res[i] = (ll) res[i] * inv2 % MOD;
            }
            return res;
        }
        void Rev() { reverse(begin() , end()); }
        void read() { for (int i = 0 ; i < (int)size() ; ++ i) { scanf("%d" , &V[i]); } }
        void print() {
            for (int i = 0 ; i < (int)size() || (puts("") , 0) ; ++ i) {
                printf("%d " , V[i]) ;
            }
        }
        #undef L
        #undef R
        #undef V
        #undef SZ
        #undef add
        #undef dec
        /*
        65537 = 2^16 + 1 , G = 3
        998244353 = 119 * 2^23 + 1 , G = 3
        1004535809 = 479 * 2^21 + 1 , G = 3 (>1e9)
        4179340454199820289 = 29 * 2^57 + 1 , G = 3 (>4e18)
        */
    } ;
} using namespace POLY ;
inline int read () {
	int x = 0, f = 1;
	char ch = getchar ();
	while (ch < '0' || ch > '9') f = ((ch == '-') ? -1 : f), ch = getchar ();
	while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar ();
	return x * f;
}
inline void write (int x) {
	if (x < 0) x = -x, putchar ('-');
	if (x >= 10) write (x / 10);
	putchar (x % 10 + '0');
}
int n, m;
int a[70][70];
int f[1005][70][70], g[1005][70][70];

int ans[20005][70];
signed main () {
//	freopen ("Para.in", "r", stdin);
//	freopen ("1.out", "w", stdout);
	n = read(), m = read();
	for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) a[i][j] = read();
	
	for(int i = 0; i < n; i++) f[0][i][i] = g[0][i][i] = 1;
	ll B = sqrt(m) + 1;
	for(int i = 1; i <= B; i++) for(int j = 0; j < n; j++) for(int k = 0; k < n; k++) for(int jj = 0; jj < n; jj++) Add(f[i][k][j], f[i-1][k][jj] * a[jj][j] % mod);
	for(int i = 1; i <= B; i++) for(int j = 0; j < n; j++) for(int k = 0; k < n; k++) for(int jj = 0; jj < n; jj++) Add(g[i][j][k], g[i-1][jj][k] * a[j][jj] % mod);
	
	for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) a[i][j] = f[B][i][j];
	memset(f, 0, sizeof f);
	for(int i = 0; i < n; i++) f[0][i][i] = 1;
	
	for(int i = 1; i <= B; i++) for(int j = 0; j < n; j++) for(int k = 0; k < n; k++) for(int jj = 0; jj < n; jj++) Add(f[i][k][j], f[i-1][k][jj] * a[jj][j] % mod);
	
	for(int x = 0; x <= B; x++) for(int k = 0; k < n; k++) for(int j = 0; (1 << j) < n; j++) for(int i = 0; i < n; i++) if(i >> j & 1) Add(f[x][i ^ (1 << j)][k], f[x][i][k]), Add(g[x][k][i ^ (1 << j)], g[x][k][i]);
	for(int d = 1; d <= m; d++) {
		int x = d / B, y = d - x * B;
		for(int k = 0; k < n; k++) for(int i = 0; i < n; i++) Add(ans[d][i], f[x][i][k] * g[y][k][i] % mod);
	}
	
	for(int i = 0; i < n; i++) {
		poly g;
		g.resize(m + 1);
		g[0] = 1;
		for(ll j = 1; j <= m; j++) g[j] = dec(0, ans[j][i]);
		g = g.Inv();
		for(ll j = 1; j <= m; j++) ans[j][i] = g[j];
	}
	for(int t = 1; t <= m; t++) for(int j = 0; (1 << j) < n; j++) for(int i = 0; i < n; i++) if(i >> j & 1) Dec(ans[t][i ^ (1 << j)], ans[t][i]);
	int Ans = 0;
	for(int i = 1; i <= m; i++) for(int j = 0; j < n; j++) Ans ^= ans[i][j];//, printf("?? %lld %lld %lld\n", i, j, ans[i][j]);
	write(Ans), putchar('\n');
    return 0;
}
/*
*/