#include <bits/stdc++.h>

using namespace std;
typedef vector<int> poly;

const int N = 66, M = 1e4 + 10, MOD = 998244353;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < MOD ? a - b + MOD : a - b; }
inline int ksm(long long a, int b) {
    long long r = 1;
    while(b) {
        if(b & 1) r = r * a % MOD;
        b >>= 1, a = a * a % MOD;
    }
    return r;
}

int rev[M];
inline void NTT(poly &A, int type) {
    static const int g = 3;
    for(int i = 1; i < A.size(); i ++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) ? A.size() >> 1 : 0);
    for(int i = 0; i < A.size(); i ++) if(i < rev[i]) swap(A[i], A[rev[i]]);
    for(int h = 2; h <= A.size(); h <<= 1) {
        int step = ksm(g, (MOD - 1) / h); if(type == -1) step = ksm(step, MOD - 2);
        for(int i = 0; i < A.size(); i += h) {
            long long mul = 1;
            for(int j = i; j < i + (h >> 1); j ++, mul = mul * step % MOD) {
                int u = A[j], v = mul * A[j + (h >> 1)] % MOD;
                A[j] = Plus(u, v), A[j + (h >> 1)] = Minus(u, v);
            }
        }
    }
    if(type == -1) {
        long long inv = ksm(A.size(), MOD - 2);
        for(int i = 0; i < A.size(); i ++) A[i] = A[i] * inv % MOD;
    }
}

poly operator + (const poly &lhs, const poly &rhs) {
    poly res(max(lhs.size(), rhs.size()), 0);
    for(int i = 0; i < lhs.size(); i ++) res[i] = Plus(res[i], lhs[i]);
    for(int i = 0; i < rhs.size(); i ++) res[i] = Plus(res[i], rhs[i]);
    return res;
}
poly operator - (const poly &lhs, const poly &rhs) {
    poly res(max(lhs.size(), rhs.size()), 0);
    for(int i = 0; i < lhs.size(); i ++) res[i] = lhs[i];
    for(int i = 0; i < rhs.size(); i ++) res[i] = Minus(res[i], rhs[i]);
    return res;
}
poly operator * (poly lhs, poly rhs) {
    int lim = 1, h = 0;
    while(lim <= lhs.size() + rhs.size()) lim <<= 1, h ++;
    lhs.resize(lim), rhs.resize(lim);
    NTT(lhs, 1), NTT(rhs, 1);
    for(int i = 0; i < lim; i ++) lhs[i] = 1ll * lhs[i] * rhs[i] % MOD;
    NTT(lhs, -1); return lhs;
}

struct matrix {
    int n, m, A[N][N];
    matrix(int _n = 0, int _m = 0): n(_n), m(_m) {
        for(int i = 0; i < n; i ++) for(int j = 0; j < m; j ++) A[i][j] = 0;
    }
};
matrix operator * (const matrix &lhs, const matrix &rhs) {
    matrix res(lhs.n, rhs.m);
    for(int i = 0; i < lhs.n; i ++) for(int j = 0; j < rhs.m; j ++)
    for(int k = 0; k < lhs.m; k ++) res.A[i][j] = Plus(res.A[i][j], 1ll * lhs.A[i][k] * rhs.A[k][j] % MOD);
    return res;
}

int n, m, f[M][N][N], ans[M][N];
matrix G[M];

int main() {
    ios::sync_with_stdio(false), cin.tie(0);

    cin >> n >> m;
    G[1] = matrix(n, n);
    for(int i = 0; i < n; i ++) for(int j = 0; j < n; j ++) cin >> G[1].A[i][j];
    // for(int i = 2; i <= m; i ++) G[i] = G[i - 1] * G[i - 1];

    for(int i = 0; i < n; i ++) f[0][i][i] = 1;
    for(int i = 0; i < m; i ++) {
        static int T[N][N];
        for(int sum = 0; sum < n; sum ++) for(int u = 0; u < n; u ++) T[sum][u] = 0;
        for(int sum = 0; sum < n; sum ++) for(int u = 0; u < n; u ++) {
            for(int v = 0; v < n; v ++) T[sum][v] = Plus(T[sum][v], 1ll * f[i][sum][u] * G[1].A[u][v] % MOD);
        }
        for(int j = 0; j < n; j ++) for(int k = 0; k < n; k ++) ans[i + 1][j & k] = Plus(ans[i + 1][j & k], T[j][k]);
        for(int sum = 0; sum < n; sum ++) for(int u = 0; u < n; u ++) {
            f[i + 1][sum][u] = Plus(f[i + 1][sum][u], T[sum][u]);
            for(int w = 0; w < n; w ++) f[i + 1][sum & u & w][w] = Plus(f[i + 1][sum & u & w][w], T[sum][u]);
        }
    }

    int res = 0;
    for(int i = 0; i <= m; i ++) for(int j = 0; j < n; j ++) res = res ^ ans[i][j];
    cout << res << '\n';

    return 0;
}