import std.stdio, std.conv, std.string, std.bigint;
import std.math, std.random, std.datetime;
import std.array, std.range, std.algorithm, std.container, std.format;
string read(){ static string[] ss; while(!ss.length) ss = readln.chomp.split; string res = ss[0]; ss.popFront; return res; }

/*

行列累乗 有向パス 数え上げ

----------------------------------------

a -> b と、b -> c をつなげると a -> c のパスになる

「aからbへの長さiのパスの総数」をx[i][a][b]とすると、x[i + j][a][c] = sum(b)(x[i][a][b] + x[j][b][c])

これを使って、K を、K/2 と K/2 に分けていけば、log K のオーダーでできるはず

----------------------------------------

上記を整理して、以下のようにすればよい

xs[l][i][j] は、i から j への長さ (1<<i) のパスの個数

xs[1] は与えられる a[i][j]に他ならない

xs[l][i][j] = sum(t)(xs[l - 1][i][t] * xs[l - 1][t][j])


これを表すために、
(long[][], long[][]) => long[][] の演算 a ** b を

(a ** b)[i][j] = sum(t)(a[i][t] * b[t][j]) 

で定義する

xs[1] = a
xs[l] = xs[l - 1] ** xs[l - 1]


そして求めるものは

ans = xs[l1] ** xs[l2] ** xs[l3] ** ... 
ただし、l1 などは (1<<l) & k > 0 であるような l

のすべての項の和

----------------------------------------

*/

const mod = 1_000_000_007;

void main(){
	int n = read.to!int;
	long k = read.to!long;
	
	long[][] as;
	foreach(i; 0 .. n){
		as ~= [[]];
		foreach(j; 0 .. n){
			as[i] ~= read.to!long;
		}
	}
	
	long[][][] xs = [as];
	for(int l = 1; (1L<<l) <= k; l ++) xs ~= prod(xs[l - 1], xs[l - 1]);
	debug writeln("xs: ", xs);
	
	long[][] p;
	foreach(l, q; xs){
		if((1L<<l) & k){
			if(p.length) p = prod(p, q);
			else p = q;
		}
	}
	
	long ans;
	foreach(i; 0 .. n) foreach(j; 0 .. n) ans += p[i][j], ans %= mod;
	ans.writeln;
}

long[][] prod(long[][] a, long[][] b){
	long[][] res;
	foreach(i; 0 .. a.length){
		res ~= [[]];
		foreach(j; 0 .. a.length){
			long x = 0;
			foreach(t; 0 .. a.length) x += a[i][t] * b[t][j], x %= mod;
			res[i] ~= x;
		}
	}
	return res;
}
