#include "bits/stdc++.h"

using namespace std;

template <int p>
struct Modint
{
	int value;

	Modint() : value(0) {}
	Modint(long x) : value(x >= 0 ? x % p : (p + x % p) % p) {}

	inline Modint &operator+=(const Modint &b)
	{
		if ((this->value += b.value) >= p)
			this->value -= p;
		return (*this);
	}
	inline Modint &operator-=(const Modint &b)
	{
		if ((this->value += p - b.value) >= p)
			this->value -= p;
		return (*this);
	}
	inline Modint &operator*=(const Modint &b)
	{
		this->value = (int)((1LL * this->value * b.value) % p);
		return (*this);
	}
	inline Modint &operator/=(const Modint &b)
	{
		(*this) *= b.inverse();
		return (*this);
	}

	Modint operator+(const Modint &b) const { return Modint(*this) += b; }
	Modint operator-(const Modint &b) const { return Modint(*this) -= b; }
	Modint operator*(const Modint &b) const { return Modint(*this) *= b; }
	Modint operator/(const Modint &b) const { return Modint(*this) /= b; }

	inline Modint &operator++(int) { return (*this) += 1; }
	inline Modint &operator--(int) { return (*this) -= 1; }

	inline bool operator==(const Modint &b) const { return this->value == b.value; }
	inline bool operator!=(const Modint &b) const { return this->value != b.value; }
	inline bool operator<(const Modint &b) const { return this->value < b.value; }
	inline bool operator<=(const Modint &b) const { return this->value <= b.value; }
	inline bool operator>(const Modint &b) const { return this->value > b.value; }
	inline bool operator>=(const Modint &b) const { return this->value >= b.value; }

	//requires that "this->value and p are co-prime"
	// a_i * v + a_(i+1) * p = r_i
	// r_i = r_(i+1) * q_(i+1) * r_(i+2)
	// q == 1 (i > 1)
	// reference: https://atcoder.jp/contests/agc026/submissions/2845729 (line:93)
	inline Modint inverse() const
	{
		assert(this->value != 0);
		int r0 = p, r1 = this->value, a0 = 0, a1 = 1;
		while (r1)
		{
			int q = r0 / r1;
			r0 -= q * r1;
			swap(r0, r1);
			a0 -= q * a1;
			swap(a0, a1);
		}
		return Modint(a0);
	}

	friend istream &operator>>(istream &is, Modint<p> &a)
	{
		long t;
		is >> t;
		a = Modint<p>(t);
		return is;
	}
	friend ostream &operator<<(ostream &os, const Modint<p> &a)
	{
		return os << a.value;
	}
};

template<class T>
struct Matrix
{
	vector<vector<T>> A;

	Matrix(size_t n) : A(n, vector<T>(n, 0)) {}
	Matrix(size_t h, size_t w) : A(h, vector<T>(w, 0)) {}
	Matrix(vector<vector<T>> &X) : A(X) {}

	inline vector<T> &operator[](int idx) {return A[idx];}
	inline const vector<T> &operator[](int idx) const {return A[idx];}

	size_t height() const {return A.size();}
	size_t width()  const {return A[0].size();}

	//ex)auto E = Matrix<int>::E(3);
	static Matrix E(int n)
	{
		Matrix e(n);
		for (int i = 0; i < n; i++) e[i][i] = 1;
		return e;
	}

	Matrix operator+(const Matrix &B) const
	{
		size_t h = this->height(), w = this->width();
		assert(h == B.height() && w == B.width());
		Matrix C(h, w);
		for (int i = 0; i < h; i++)
			for (int j = 0; j < w; j++)
			{
				C[i][j] = (*this)[i][j] + B[i][j];
			}
		return C;
	}

	Matrix operator-(const Matrix &B)
	{
		size_t h = this->height(), w = this->width();
		assert(h == B.height() && w == B.width());
		Matrix C(h, w);
		for (int i = 0; i < h; i++)
			for (int j = 0; j < w; j++)
			{
				C[i][j] = (*this)[i][j] - B[i][j];
			}
		return C;
	}

	Matrix operator*(const Matrix &B)
	{
		size_t h = this->height(), x = this->width(), w = B.width();
		assert(x == B.height());
		Matrix C(h, w);
		for (size_t i = 0; i < h; i++)
			for (size_t k = 0; k < x; k++)
				for (size_t j = 0; j < w; j++)
				{
					C[i][j] += (*this)[i][k] * B[k][j];
				}
		return C;
	}

	Matrix &operator+=(const Matrix &B) { return (*this) = (*this) + B; }
	Matrix &operator-=(const Matrix &B) { return (*this) = (*this) - B; }
	Matrix &operator*=(const Matrix &B) { return (*this) = (*this) * B; }

	Matrix power(long k)
	{
		auto n = this->height();
		assert(k >= 0 && this->width() == n);
		auto R = Matrix<T>::E(n), C = Matrix(*this);
		while(k)
		{
			if (k&1) R *= C;
			C *= C;
			k >>= 1;
		}
		return R;
	}

	friend ostream &operator<<(ostream &o, const Matrix &A)
	{
		for (int i = 0; i < A.height(); i++)
		{
			for (int j = 0; j < A.width(); j++)
			{
				o << A[i][j] << " ";
			}
			o << endl;
		}
		return o;
	}
};

const int MOD = 1e9+7;

using Int = Modint<MOD>;

int main(void)
{
	long N, K;
	cin >> N >> K;
	Matrix<Int> A(N);

	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
	{
		cin >> A[i][j];
	}
	A = A.power(K);
	Int ans;
	for (int i = 0; i < N; i++)
		for (int j = 0; j < N; j++)
	{
		ans += A[i][j];
	}
	cout << ans << endl;

	return 0;
}


Measured memory_bytes: 256