#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#include <string>
#include <set>
#include <bitset>
#include <unordered_map>
#include <cmath>
#include <functional>
#include <map>
#include <cstdlib>

using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T>
using Vvec = vector<vector<T> >;

const ll MOD = 1e9+7;

template <class T>
class Matrix
{
public:
    // element
    std::vector<std::vector<T> > mat;

    // constructor
    Matrix<T>(){
        mat.resize(1);
        mat[0].resize(1);
    }
    Matrix<T>(size_t rows, size_t cols){
        mat.resize(rows);
        for(auto& v: mat) v.resize(cols);
    }
    Matrix<T>(const Matrix<T>& m){
        mat.resize(m.rows());
        for(int i=0; i<m.rows(); i++) std::copy(m[i].begin(), m[i].end(), std::back_inserter(mat[i]));
    }
    Matrix<T>(Matrix<T>&& m) noexcept{
        mat = std::move(m.mat);
    }
    ~Matrix<T>(){};

    // assignment
    Matrix<T>& operator=(const Matrix<T>& m){
        mat.resize(m.rows());
        for(int i=0; i<m.rows(); i++) std::copy(m[i].begin(), m[i].end(), std::back_inserter(mat[i]));
    }
    Matrix<T>& operator=(const Matrix<T>&& m){
        mat = std::move(m.mat);
        return *this;
    }

    // get size
    size_t rows() const {return mat.size();}
    size_t cols() const {return mat[0].size();}

    // transpose
    Matrix<T> transpose(){
        Matrix<T> ret(cols(), rows());
        for(size_t i=0; i<rows(); i++){
            for(size_t j=0; j<cols(); j++) ret[j][i] = mat[i][j];
        }
        return ret;
    }

    // get element
    std::vector<T>& operator[](std::size_t i) &{
        return mat[i];
    }
    const std::vector<T>& operator[](std::size_t i) const&{
        return mat[i];
    };
    // std::vector<T> operator[](std::size_t i) const&&;

    // unary negation
    // Matrix<T> operator-() const;

    // compound assignment
    Matrix<T>& operator+=(const Matrix<T>& m){
        for(size_t i=0; i<rows(); i++){
            for(size_t j=0; j<cols(); j++){
                mat[i][j] += m[i][j];
                mat[i][j] %= MOD;
            }
        }
        return *this;
    }
    Matrix<T>& operator-=(const Matrix<T>& m){
        for(size_t i=0; i<rows(); i++){
            for(size_t j=0; j<cols(); j++){
                mat[i][j] -= m[i][j];
                if(mat[i][j] < 0) mat[i][j] += MOD;
                mat[i][j] %= MOD;
            }
        }
        return *this;
    }
    Matrix<T>& operator*=(const Matrix<T>& m){
        Matrix<T> t(this->transpose());
        for(size_t i=0; i<rows(); i++){
            mat[i].resize(m.cols());
            for(size_t j=0; j<m.cols(); j++){
                mat[i][j] = 0;
                for(size_t k=0; k<m.rows(); k++){
                    mat[i][j] += t[k][i] * m[k][j];
                    mat[i][j] %= MOD;
                }
            }
        }
        return *this;
    }

    // identity
    Matrix<T> identity(const size_t N){
        Matrix<T> ret(N, N);
        for(int i=0; i<N; i++) ret[i][i] = 1;
        return ret;
    }

    // pow
    Matrix<T> pow(long long k){
        Matrix<T> ret = identity(rows());
        Matrix<T> X(*this);
        while(k>0){
            if(k&1) ret *= X;
            X = X * X;
            k /= 2;
        }
        return ret;
    }
};

// arithmetic
template <class T>
Matrix<T> operator+(const Matrix<T>& m1, const Matrix<T>& m2){
    return Matrix<T>(m1) += m2;
}

template <class T>
Matrix<T> operator-(const Matrix<T>& m1, const Matrix<T>& m2){
    return Matrix<T>(m1) -= m2;
}

template <class T>
Matrix<T> operator*(const Matrix<T>& m1, const Matrix<T>& m2){
    return Matrix<T>(m1) *= m2;
}

template <class T>
void debug(T& v)
{
    for(auto& x: v) cout << x << " ";
    cout << endl;
}

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

    Matrix<ll> x(N, 1);
    for(int i=0; i<N; i++) x[i][0] = 1;

    x = a.pow(K) * x;
    ll ans = 0;
    for(int i=0; i<N; i++){
        ans += x[i][0];
        ans %= MOD;
    }

    cout << ans << endl;
}

Measured memory_bytes: 384