#pragma GCC optimize(2, 3, "Ofast", "inline")
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
//#define int long long
//#define double long double
using i64 = long long;
using ui64 = unsigned long long;
#define inf (int)0x3f3f3f3f3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define yn(x) cout << (x ? "yes" : "no") << endl
#define Yn(x) cout << (x ? "Yes" : "No") << endl
#define YN(x) cout << (x ? "YES" : "NO") << endl
#define mem(x, i) memset(x, i, sizeof(x))
#define cinarr(a, n) for (int _ = 1; _ <= n; _++) cin >> a[_]
#define cinstl(a) for (auto& _ : a) cin >> _
#define coutarr(a, n) for (int _ = 1; _ <= n; _++) cout << a[_] << " \n"[_ == n]
#define coutstl(a) for (const auto& _ : a) cout << _ << ' '; cout << endl
#define all(x) (x).begin(), (x).end()
#define ls (s << 1)
#define rs (s << 1 | 1)
#define ft first
#define se second
#define pii pair<int, int>
#ifdef DEBUG
    #include "debug.h"
#else
    #define dbg(...) void(0)
#endif

const int N = 2e5 + 5;
//const int M = 1e5 + 5;
const int mod = 998244353;
//const int mod = 1e9 + 7;
template <typename T> T ksm(T a, i64 b) { T ans = 1; for (; b; a = 1ll * a * a, b >>= 1) if (b & 1) ans = 1ll * ans * a; return ans; }
template <typename T> T ksm(T a, i64 b, T m) { T ans = 1; for (; b; a = 1ll * a * a % m, b >>= 1) if (b & 1) ans = 1ll * ans * a % m; return ans; }

int a[N];
int n, m, t, k, q, r;

template <int P> struct MInt {
    int x;
    MInt() : x(0) {}
    MInt(const signed& x) : x(norm(x % getMod())) {}
    MInt(const long long& x) : x(norm(x % getMod())) {}

    static int Mod;
    static int getMod() { return P > 0 ? P : Mod; }
    static void setMod(int _Mod) { Mod = _Mod; }
    int norm(const int& x) const { return x < 0 ? x + getMod() : (x >= getMod() ? x - getMod() : x); }
    int val() const { return x; }
    explicit operator int() const { return x; }
    MInt operator - () const { MInt res; res.x = norm(getMod() - x); return res; }
    MInt ksm(const long long& x) const {
        MInt a = *this, ans = 1;
        for (long long pw = x; pw; a *= a, pw >>= 1) if (pw & 1) ans *= a;
        return ans;
    }
    MInt inv() const { assert(x != 0); return ksm(getMod() - 2); }
    MInt& operator += (const MInt& b) & { x = norm(x + b.x); return *this; }
    MInt& operator -= (const MInt& b) & { x = norm(x - b.x); return *this; }
    MInt& operator *= (const MInt& b) & { x = norm(1ll * x * b.x % getMod()); return *this; }
    MInt& operator /= (const MInt& b) & { return *this *= b.inv(); }
    MInt& operator ++ () & { return *this += 1; }
    MInt& operator -- () & { return *this -= 1; }
    const MInt operator ++ (signed) { MInt old = *this; ++(*this); return old; }
    const MInt operator -- (signed) { MInt old = *this; --(*this); return old; }
    friend MInt operator + (const MInt& a, const MInt& b) { MInt res = a; res += b; return res; }
    friend MInt operator - (const MInt& a, const MInt& b) { MInt res = a; res -= b; return res; }
    friend MInt operator * (const MInt& a, const MInt& b) { MInt res = a; res *= b; return res; }
    friend MInt operator / (const MInt& a, const MInt& b) { MInt res = a; res /= b; return res; }
    friend istream& operator >> (istream& in, MInt& a) { long long v; in >> v; a = MInt(v); return in; }
    friend ostream& operator << (ostream& out, const MInt& a) { return out << a.val(); }
    friend bool operator == (const MInt& a, const MInt& b) { return a.val() == b.val(); }
    friend bool operator != (const MInt& a, const MInt& b) { return a.val() != b.val(); }
    friend bool operator < (const MInt& a, const MInt& b) { return a.val() < b.val(); }
    friend bool operator > (const MInt& a, const MInt& b) { return a.val() > b.val(); }
    friend bool operator <= (const MInt& a, const MInt& b) { return a.val() <= b.val(); }
    friend bool operator >= (const MInt& a, const MInt& b) { return a.val() >= b.val(); }
};
using Mint = MInt<mod>;
template<> int MInt<0>::Mod = 1;

template <typename T = int> struct Matrix {
    int m, n; // m 行 n 列的矩阵
    vector<vector<T>> v;

    Matrix(): n(0), m(0) { v.resize(0); }
    Matrix(int r, int c, T num = T()) : m(r), n(c) {
        v.resize(m + 1, vector<T>(n + 1, num));
    }
    Matrix(int n) : m(n), n(n) { // 单位矩阵的构造函数
        v.resize(n + 1, vector<T>(n + 1, 0));
        for (int i = 1; i <= n; i++) v[i][i] = 1;
    }

    Matrix& operator += (const Matrix& b) & {
        assert(m == b.m && n == b.n);
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                v[i][j] += b[i][j];
        return *this;
    }
    Matrix& operator -= (const Matrix& b) & {
        assert(m == b.m && n == b.n);
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                v[i][j] -= b[i][j];
        return *this;
    }
    Matrix& operator *= (const T& b) & {
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= n; j++)
                v[i][j] *= b;
        return *this;
    }
    Matrix& operator *= (const Matrix& b) & {
        assert(n == b.m);
        Matrix ans(m, b.n);
        for (int i = 1; i <= m; i++)
            for (int j = 1; j <= b.n; j++)
                for (int k = 1; k <= n; k++)
                    ans[i][j] += v[i][k] * b[k][j];
        return *this = ans;
    }
    friend Matrix operator + (const Matrix& a, const Matrix& b) {
        Matrix ans = a; ans += b; return ans;
    }
    friend Matrix operator - (const Matrix& a, const Matrix& b) {
        Matrix ans = a; ans -= b; return ans;
    }
    friend Matrix operator * (const Matrix& a, const T& b) {
        Matrix ans = a; a *= b; return ans;
    }
    friend Matrix operator * (const Matrix& a, const Matrix& b) {
        Matrix ans = a; ans *= b; return ans;
    }
    Matrix trans() const {
        Matrix ans(n, m);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
                ans[i][j] = v[j][i];
        return ans;
    }
    Matrix ksm(const long long& x) const {
        assert(n == m);
        Matrix ans(n), a = *this;
        for (long long pw = x; pw; a *= a, pw >>= 1) if (pw & 1) ans *= a;
        return ans;
    }
    vector<T>& operator [] (const int& t) { return v[t]; }
    const vector<T>& operator [] (const int& t) const { return v[t]; }

    friend bool operator == (const Matrix& a, const Matrix& b) {
        assert(a.m == b.m && a.n == b.n);
        for (int i = 1; i <= a.m; i++)
            for (int j = 1; j <= a.n; j++)
                if (a[i][j] != b[i][j])
                    return false;
        return true;
    }
    friend bool operator != (const Matrix& a, const Matrix& b) {
        return !(a == b);
    }

    friend istream& operator >> (istream& in, Matrix& x) {
        in >> x.m >> x.n;
        x.v.resize(x.m + 1, vector<T>(x.n + 1, 0));
        for (int i = 1; i <= x.m; i++)
            for (int j = 1; j <= x.n; j++)
                in >> x[i][j];
        return in;
    }
    friend ostream& operator << (ostream& out, const Matrix& x) {
        for (int i = 1; i <= x.m; i++)
            for (int j = 1; j <= x.n; j++)
                out << x[i][j] << " \n"[j == x.n];
        return out;
    }
};

template <typename T> T del(int n, Matrix<T> a) {
    T ans = 1, sgn = 1;
    for (int i = 1; i <= n; i++) {
        int t = i;
        for (int j = i; j <= n; j++) if (a[j][i] != 0) { t = j; break; }
        if (a[t][i] == 0) return 0;
        if (t != i) swap(a[t], a[i]), sgn *= -1;
        for (int j = i + 1; j <= n; j++) {
            T div = a[j][i] / a[i][i];
            for (int k = i; k <= n; k++)
                a[j][k] = a[j][k] - div * a[i][k];
        }
        ans *= a[i][i];
    }
    return ans * sgn;
}

template<typename T> struct Comb {
    int n;
    vector<T> _fac, _infac, _inv;
    Comb() : n(0), _fac{1}, _infac{1}, _inv{0} {}
    Comb(int n) : Comb() { init(n); }

    void init(int m) {
        if (m <= n) return;
        _fac.resize(m + 1), _infac.resize(m + 1), _inv.resize(m + 1);
        for (int i = n + 1; i <= m; i++)
            _fac[i] = _fac[i - 1] * i;
        _infac[m] = 1 / _fac[m];
        for (int i = m; i > n; i--) {
            _infac[i - 1] = _infac[i] * i;
            _inv[i] = _infac[i] * _fac[i - 1];
        }
        n = m;
    }
    T fac(int m) { if (m > n) init(2 * m); return _fac[m]; }
    T infac(int m) { if (m > n) init(2 * m); return _infac[m]; }
    T inv(int m) { if (m > n) init(2 * m); return _inv[m]; }
    T a(int n, int m) { return n < m || m < 0 ? 0 : fac(n) * infac(n - m); }
    T c(int n, int m) { return n < m || m < 0 ? 0 : fac(n) * infac(n - m) * infac(m); }
};
Comb<Mint> comb;

void work() {
    cin >> n >> r; r--;

    Matrix<Mint> A(n, n), Din(n, n), Dout(n, n);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            cin >> A[i][j];
            if (A[i][j] == 1) {
                Dout[i][i] += 1;
                Din[j][j] += 1;
            }
        }
    }
    Matrix Lin = Din - A, Lout = Dout - A;
    k = int(Din[1][1]);

    Mint tleaf = del(n - 1, Lin);
    Mint troot = del(n - 1, Lout);
    assert(tleaf == troot);

    // T(D)
    Mint t = troot * n;

    // T(L^r(D))=k^{nk^r-n}T(D)
    Mint T = Mint(k).ksm(n).ksm(ksm(k, r, mod - 1) - 1) * t;

    // use E(D)=K(D)[(k-1)!]^n to calculate E(L^r(D))
    Mint E1 = T / (n * Mint(k).ksm(r)) * comb.fac(k - 1).ksm(n).ksm(ksm(k, r, mod - 1));

    // E(L^r(D))=\frac{(k!)^{nk^r}}/{nk^{r+n}}T(D)
    Mint E2 = comb.fac(k).ksm(n).ksm(ksm(k, r, mod - 1)) / (n * Mint(k).ksm(r + n)) * t;
    assert(E1 == E2);
    cout << E1 * n * Mint(k).ksm(r + 1) << endl;
}

signed main() {
#ifdef LOCAL
    freopen("C:\\Users\\admin\\CLionProjects\\Practice\\data.in", "r", stdin);
    freopen("C:\\Users\\admin\\CLionProjects\\Practice\\data.out", "w", stdout);
#endif
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int Case = 1;
    //cin >> Case;
    while (Case--) work();
    return 0;
}