#ifndef ENV_AC
    #define ENV_AC
    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    #include <fstream>
    #include <iostream>
    #include <sstream>
    #include <iomanip>
    #include <algorithm>
    #include <bitset>
    #include <array>
    #include <vector>
    #include <queue>
    #include <set>
    #include <cmath> // 変数名にy1が使えなくなるかも…。
    #include <map>
    #include <unordered_map>
    #include <unordered_set>
    #include <limits>
    #include <functional>
    #include <string>

    using int128_t = __int128_t;
    std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
        int64_t tmp; input >> tmp; value = tmp;
        return input;
    }
    std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
        output << (int64_t)value;
        return output;
    }

    namespace std {
        template<> class hash<int128_t>{
            public:
            size_t operator () ( const int128_t &x ) const {
                int64_t INF64 = std::numeric_limits<int64_t>::max();
                int64_t y1 = x / INF64;
                int64_t y2 = x % INF64;
                return hash<int64_t>()(y1) ^ hash<int64_t>()(y2);
            }
        };
    }

    int128_t imax(const int128_t a, const int128_t b) { return std::max(a, b); } // std::max, std::min は型が違うとエラーになるため、ラッパーを作る。
    int128_t imin(const int128_t a, const int128_t b) { return std::min(a, b); }
    int128_t iabs(const int128_t x) { return 0 <= x ? x : -x; }
    int128_t ipow(const int128_t x, const int128_t n) { int128_t ret = 1; for (int i = 0; i < n; i++) { ret *= x; } return ret; }

    #define rep(i, begin, end) for(int64_t i = ((int64_t)begin); i <= ((int64_t)end); i++) // (int64_t)end としておくと、end = v.size() - 2 みたいな入力で、v.size()が1でも正常(end = -1になる）に挙動する。
    #define rev(i, begin, end) for(int64_t i = ((int64_t)begin); ((int64_t)end) <= i; i--) // int128_tにすると、3重ループでコンパイルエラーになったのでint64_tにしておく。

    #define input1(begin, end, v1) v1.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i]; }
    #define input2(begin, end, v1, v2) v1.resize((end)+1); v2.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i]; } 
    #define input3(begin, end, v1, v2, v3) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i]; }
    #define input4(begin, end, v1, v2, v3, v4) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i]; } 
    #define input5(begin, end, v1, v2, v3, v4, v5) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); v5.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i] >> v5[i]; }  
    // input_arrayはbegin = 0のときのみ動作確認。Aの要素の型をテンプレートにして関数にしたほうが丁寧かもしれない。
    #define input_array(begin, N, M, A) A.resize((begin)+(N)); for (int i = 0; i < (begin)+(N); i++) { A[i].resize((begin)+(M)); } for (int i = begin; i < (begin)+(N); i++) { for (int j = begin; j < (begin)+(M); j++) { std::cin >> A[i][j]; }}

    std::vector<int> irange(const int begin, const int end) {
        std::vector<int> ret; for (int i = begin; i <= end; i++) { ret.push_back(i); }
        return ret;
    }

    template <typename T>
    std::vector<T> accumulate_vec(const std::vector<T>& vec, const bool reverse = false) {
        std::vector<T> ret; ret.resize(vec.size());
        if (reverse == false) {
            ret[0] = vec[0];
            for (int i = 1; i < ret.size(); i++) {
                ret[i] = ret[i-1] + vec[i];
            }
        } else {
            ret[ret.size()-1] = vec[ret.size()-1];
            for (int i = ret.size() - 2; 0 <= i; i--) {
                ret[i] = ret[i+1] + vec[i];
            }
        }
        return ret;
    }

    template <typename T>
    void printvec(const std::vector<T>& vec) {
        for (int i = 0; i < vec.size(); i++) { std::cout << vec[i] << " "; } std::cout << std::endl;
    }
#endif

int128_t cal_mod(const int128_t n, const int128_t mod) {
    // n % modを計算する。ただしmod <= 0 ならば何もしない。nが負の場合、正にして補正する。
    if (mod <= 0) {
        return n;
    } else if (0 <= n) {
        return n % mod;
    } else {
        int128_t tmp = (-n) / mod + 1;
        return (n + tmp * mod) % mod;
    }
}

int128_t pow_mod(int128_t x, int128_t n, const int128_t mod) {
    // 累乗の計算。mod <= 0ならば余りの計算は行わない。
    int128_t ret = 1;
    while (n > 0) {
        if (n & 1) { ret = cal_mod(ret * x, mod); }
        x = cal_mod(x * x, mod);
        n = (n >> 1);
    }
    return ret;
}

int128_t dot_product(const std::vector<int128_t>& a, const std::vector<int128_t>& b, const int128_t mod) {
    // mod に正の値を入れると、modの余りを計算する。デフォルト引数でmod = -1とすれば、入力を省ける。
    assert(a.size() == b.size());
    int128_t ret = 0;;
    for (int i = 0; i < a.size(); i++) {
        ret += a[i] * b[i];
    }
    return cal_mod(ret, mod);
}

// 行列クラス。0-indexedとする。
class Matrix {
    public:
    std::vector<std::vector<int128_t>> M;

    void reset(const int H, const int W) {
        M.resize(H);
        for (int i = 0; i < H; i++) {
            M[i].resize(W, 0);
        }
    }
    Matrix() {}
    Matrix(const int H, const int W) {
        reset(H, W);
    }
    Matrix(const std::vector<std::vector<int128_t>>& _M) {
        M = _M;
    }
    int size_r() const { return M.size(); }
    int size_c() const { assert(0 < size_r()); return M[0].size(); }

    void set_diag(int128_t v) {
        reset(size_r(), size_c());
        for (int i = 0; i < std::min(size_r(), size_c()); i++) {
            M[i][i] = v;
        }
    }
};

std::vector<int128_t> mat_mul_vec(const Matrix& mat, const std::vector<int128_t>& vec, const int128_t mod) {
    // 行列とベクトルの積。除算が不要の場合デフォルトでmod = -1とする。
    assert(mat.size_c() == vec.size());
    std::vector<int128_t> ret;
    ret.resize(mat.size_r());
    for (int i = 0; i < ret.size(); i++) {
        ret[i] = dot_product(mat.M[i], vec, mod);
    }
    return ret;
}

Matrix transpose(const Matrix& mat) {
    Matrix ret = Matrix(mat.size_c(), mat.size_r());
    for (int i = 0; i < ret.size_r(); i++) {
        for (int j = 0; j < ret.size_c(); j++) {
            ret.M[i][j] = mat.M[j][i];
        }
    }
    return ret;
}

Matrix mat_mul(const Matrix& A, const Matrix& B, const int128_t mod) {
    // 行列の積。除算が不要の場合デフォルトでmod = -1とする。
    assert(A.size_c() == B.size_r());
    const Matrix tB = transpose(B);
    Matrix ret = Matrix(A.size_r(), B.size_c());
    for (int i = 0; i < ret.size_r(); i++) {
        for (int j = 0; j < ret.size_c(); j++) {
            ret.M[i][j] = dot_product(A.M[i], tB.M[j], mod);
        }
    }
    return ret;
}

Matrix mat_pow(Matrix A, int128_t n, const int128_t mod) {
    assert(A.size_r() == A.size_c());
    Matrix B = Matrix(A.size_r(), A.size_c());
    B.set_diag(1);

    while (n > 0) {
        if (n & 1) { B = mat_mul(B, A, mod); }
        A = mat_mul(A, A, mod);
        n = (n >> 1);
    }
    return B;
}

//--code begin--

int128_t N, K;
//std::vector<int128_t> h, a;
std::vector<std::vector<int128_t>> a;
//std::string ;
//std::vector<std::string> a;
//double X;
//std::vector<double> p;

const int128_t MAX_N = 2e5 + 10;
const int128_t MOD = 1e9 + 7;
//const int128_t INF = std::numeric_limits<int64_t>::max();
//const double EPS = 1.0e-15;


int main(int argc, char **argv) {
    std::cin.tie(0);
   	std::ios::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(15);

    std::cin >> N >> K;
    input_array(0, N, N, a);

    Matrix Mat = Matrix(a);
    Mat = mat_pow(Mat, K, MOD);

    int128_t ret = 0;
    rep (i, 0, N - 1) {
        rep (j, 0, N - 1) {
            ret += Mat.M[i][j];
            ret %= MOD;
        }
    }
    

    std::cout << ret << std::endl;
    

    return 0;
}

Measured memory_bytes: 512