#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

// a^p
template<class T>
T pow(T ide, T a, long long p){
    T b = ide; //
    while(p > 0){
        if(p%2 == 1) b *= a;
        p /= 2;
        a *= a;
    }
    return b;
}

long long const mod = 1000000007;
// long long const mod = 998244353;

// - - - - mint - - - - //
struct mint{
    typedef long long ll;
    ll v = 0;
    mint(){}
    mint(ll v) : v(v%mod) {}
    mint(const mint& v) : v(v.v) {}

    static mint pow(mint a, long long p){
        mint r(1);
        while(p > 0){
            if(p%2 == 1) r *= a;
            a *= a;
            p /= 2;
        }
        return r;
    }
    static mint inv(mint a){
        return pow(a, mod-2);
    }

    mint operator-()const{ return mint((mod-v)%mod); }
    mint& operator+=(const mint& r){v += r.v; v %= mod; return *this;}
    mint& operator-=(const mint& r){v += mod-r.v; v %= mod; return *this;}
    mint& operator*=(const mint& r){v *= r.v; v %= mod; return *this;}
    mint& operator/=(const mint& r){*this *= inv(r); return *this;}

    mint operator+(const mint& r) { return mint(*this) += r; }
    mint operator-(const mint& r) { return mint(*this) -= r; }
    mint operator*(const mint& r) { return mint(*this) *= r; }
    mint operator/(const mint& r) { return mint(*this) /= r; }
};

mint operator+(const mint& l, const mint& r) { return mint(l) += r; }
mint operator-(const mint& l, const mint& r) { return mint(l) -= r; }
mint operator*(const mint& l, const mint& r) { return mint(l) *= r; }
mint operator/(const mint& l, const mint& r) { return mint(l) /= r; }

istream& operator>>(istream& is, mint& m){ is >> m.v; return is; }
ostream& operator<<(ostream& os, const mint& m){ os << m.v; return os; }

// - - - - matrix - - - - //
template<class T>
struct M{
    int n = 0;
    static T ai;
    static T mi;
    vector< vector< T > > v;
    M(int n){
        this->n = n;
        v.assign(n, vector<T>(n, ai));
    }
    M(int n, vector< vector< T > > v){
        this->n = n;
        (this->v).assign(v.begin(), v.end());
    }
    M(const M& m){
        n = m.n;
        v.assign(m.v.begin(), m.v.end());
    }

    M& operator+=(const M& r){
        for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) v[i][j] += r.v[i][j];
        return *this;
    }
    M& operator-=(const M& r){
        for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) v[i][j] -= r.v[i][j];
        return *this;
    }
    M& operator*=(const M& r){
        M c(n);
        for(int i = 0; i < n; i++) for(int j = 0; j < n; j++) for(int k = 0; k < n; k++) c.v[i][j] += v[i][k] * r.v[k][j];
        *this = c;
        return *this;
    }

    static M ide(int n){
        M c(n);
        for(int i=0;i<n;i++) c.v[i][i] = M<T>::mi;
        return c;
    }
};
template<class T> M<T> operator+(const M<T>& l, const M<T>& r) { return M<T>(l) += r; }
template<class T> M<T> operator-(const M<T>& l, const M<T>& r) { return M<T>(l) -= r; }
template<class T> M<T> operator*(const M<T>& l, const M<T>& r) { return M<T>(l) *= r; }
template<class T> T M<T>::ai;
template<class T> T M<T>::mi;
// - - - - matrix - - - - //

int main(void){
    M<mint>::ai = mint(0);
    M<mint>::mi = mint(1);

    int n;
    long long k;
    cin >> n >> k;
    M<mint> m(n);
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            int a;
            cin >> a;
            if(a == 1) m.v[i][j] = 1;
        }
    }
    M<mint> matk = pow< M<mint> >(M<mint>::ide(n), m, k);
    mint ans = 0;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++) ans += matk.v[i][j];
    }
    cout << ans << endl;
}


Measured memory_bytes: 384