#include <bits/stdc++.h>

using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;

template<class T>inline bool chmax(T &a, const T &b) { if (b > a) { a = b; return true; } return false; }
template<class T>inline bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }

constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr int MOD = 1e9 + 7;
constexpr long long LINF = 1e18;
constexpr double EPS = 1e-10;
constexpr double PI = M_PI;

template<int mod>
class ModInt {
    private:
        long long val;
    public:
        constexpr ModInt(const long long v = 0) : val(v%mod) { if (val < 0) val += mod; }
        constexpr ModInt(const ModInt &v) : val(v.val) {}
        constexpr ModInt &operator=(const long long v) { val = v; return *this; }
        constexpr ModInt &operator=(const ModInt &v) { if (this != &v) val = v.val; return *this; }
        constexpr ModInt operator+() const { return ModInt(val); }
        constexpr ModInt operator-() const { return ModInt(-val); }
        constexpr ModInt operator+(const ModInt &v) const { return ModInt(*this) += v; }
        constexpr ModInt operator-(const ModInt &v) const { return ModInt(*this) -= v; }
        constexpr ModInt operator*(const ModInt &v) const { return ModInt(*this) *= v; }
        constexpr ModInt operator/(const ModInt &v) const { return ModInt(*this) /= v; }
        constexpr ModInt &operator+=(const ModInt &v) { val += v.val; if (val >= mod) val -= mod; return *this; }
        constexpr ModInt &operator-=(const ModInt &v) { val -= v.val; if (val < 0) val += mod; return *this; }
        constexpr ModInt &operator*=(const ModInt &v) { val *= v.val; if (val >= mod) val %= mod; return *this; }
        constexpr ModInt &operator/=(const ModInt &v) { val *= v.inverse().val; if (val >= mod) val %= mod; return *this; }
        constexpr ModInt &operator++() { ++val; if (val >= mod) val -= mod; return *this; }
        constexpr ModInt &operator--() { --val; if (val < 0) val += mod; return *this; }
        constexpr ModInt operator++(int) { ModInt tmp(*this); operator++(); return tmp; }
        constexpr ModInt operator--(int) { ModInt tmp(*this); operator--(); return tmp; }
        constexpr bool operator==(const ModInt &v) const { return val == v.val; }
        constexpr bool operator!=(const ModInt &v) const { return !(*this == v); }
        friend std::istream &operator>>(std::istream &s, ModInt &v) { long long tmp; s >> tmp; v = ModInt(tmp); return s; }
        friend std::ostream &operator<<(std::ostream &s, const ModInt &v) { return s << v.val; }
        constexpr ModInt inverse() const {
            long long n = val, res = 1;
            while (n > 1) {
                res *= (mod - mod / n);
                res %= mod;
                n = mod % n;
            }
            return ModInt(res);
        }
        static constexpr ModInt modpow(ModInt v, long long n) {
            ModInt res(1);
            for ( ; n>0; n>>=1) {
                if (n & 1) res *= v;
                v *= v;
            }
            return res;
        }
};

using MInt = ModInt<MOD>;

template<class T>
class Matrix {
    private:
        int row, col;
        std::vector<std::vector<T>> val;
    public:
        Matrix(int row, int col) : row(row), col(col), val(row, std::vector<T>(col)) {}
        Matrix(const Matrix &A) : row(A.row), col(A.col), val(A.val) {}
        Matrix &operator=(const Matrix &A) {
            row = A.row;
            col = A.col;
            val = A.val;
            return *this;
        }
        Matrix operator+(const Matrix &A) const { return Matrix(*this) += A; }
        Matrix operator-(const Matrix &A) const { return Matrix(*this) -= A; }
        Matrix operator*(const Matrix &A) const { return Matrix(*this) *= A; }
        Matrix &operator+=(const Matrix &A) {
            if (row != A.row || col != A.col) throw "size error at operator +\n";
            for (int i=0; i<row; ++i) {
                for (int j=0; j<col; ++j) {
                    val[i][j] += A[i][j];
                }
            }
            return *this;
        }
        Matrix &operator-=(const Matrix &A) {
            if (row != A.row || col != A.col) throw "size error at operator -\n";
            for (int i=0; i<row; ++i) {
                for (int j=0; j<col; ++j) {
                    val[i][j] -= A[i][j];
                }
            }
            return *this;
        }
        Matrix &operator*=(const Matrix &A) {
            if (col != A.row) throw "size error at operator *\n";
            Matrix R(row, A.col);
            for (int i=0; i<row; ++i) {
                for (int j=0; j<A.col; ++j) {
                    for (int k=0; k<col; ++k) {
                        R[i][j] += val[i][k] * A[k][j];
                    }
                }
            }
            return *this = R;
        }
        std::vector<T> &operator[](int i) { return val[i]; }
        const std::vector<T> &operator[](int i) const { return val[i]; }
        void resize(int r, int c) {
            row = r;
            col = c;
            val.resize(row);
            for (int i=0; i<row; ++i) val[i].resize(col);
        }
        static Matrix E(int n) {
            Matrix R(n, n);
            for (int i=0; i<n; ++i) R[i][i] = 1;
            return R;
        }
        static Matrix pow(Matrix A, long long n) {
            if (A.row != A.col) throw "size error at pow\n";
            Matrix R(E(A.row));
            for ( ; n>0; n>>=1) {
                if (n & 1) R *= A;
                A *= A;
            }
            return R;
        }
};

void solve() {
    int N;
    ll K;
    cin >> N >> K;
    Matrix<MInt> a(N, N);
    for (int i=0; i<N; ++i) {
        for (int j=0; j<N; ++j) {
            cin >> a[i][j];
        }
    }

    Matrix<MInt> mat(Matrix<MInt>::pow(a, K));
    MInt res = 0;
    for (int i=0; i<N; ++i) {
        for (int j=0; j<N; ++j) {
            res += mat[i][j];
        }
    }
    cout << res << '\n';
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout << fixed << setprecision(20);

    solve();

    return 0;
}


Measured memory_bytes: 3720