/**
    ▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
        Make it happen now, not tomorrow.
        Tomorrow is a  loser's excuse.
    ▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
**/
#ifndef _GLIbCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>

#if __cplu >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#include <cstring>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include<random>
#include <chrono>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplu >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <time.h>
#endif
#define __ ios_base::sync_with_stdio(false);cin.tie(NULL);
using namespace std;
// #define INF 0x7f7f7f7f
#define ull unsigned long long int
#define pii pair<int,int>
#define ll long long int
#define ld long double
#define MSET(x,y) memset(x,y,sizeof(x))
// #define l long
#define se second
#define fi first
#define NIL 0
#define UNVISITED -1
#define EXPOLORED 0
#define mk make_pair
#define pb push_back
#define sc(n) scanf("%d",&n)
#define NIL 0
#define pii pair<int,int>
#define eps 1e-9
#define all(x) x.begin(),x.end()
#define me(u,v,w) make_pair(w,make_pair(u,v))
#define sqr(x) x*x
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define inrange(x,y,row,col) (x>=0 && y>=0 && x<row && y<col)
#define foreach(e, x) for(__typeof(x.begin()) e = x.begin(); e != x.end(); ++ e)
// #define add(a,b) (a + b >= MOD ? a+b-MOD:a+b)
#define hs(c1,c2) (256*min(c1,c2) + max(c1,c2))
typedef struct{ int sum,suf,pre,max;} Node;
int toint(const string &s) { stringstream ss; ss << s; int x; ss >> x; return x; }
// const int MAXN = 3010;

/**
    ▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
        Make it happen now, not tomorrow.
        Tomorrow is a loser's excuse.
    ▂▃▅▇█▓▒░۩۞۩ ۩۞۩░▒▓█▇▅▃▂
There is nothin in a catterpillar that tells you its going to be a butterfly ---------!
//--- Matrix Expo//

//-- Matix Expo//
**/
//Trie
// struct node
// {
//     node *child[2];
//     node(){
//         child[0] = child[1] = NULL;
//     }
// };
// node *root;
// ll all[N];
// //Trie
// deque<short> binary(ll x){
//     deque<short>  ans;
//     while(x){
//         ans.push_front(x%2);
//         x /= 2;
//     }
//     while(ans.size()<50){
//         ans.push_front(0);
//     }
//     return ans;
// }
// void add(ll x){
//     deque<short> a = binary(x);
//     node *c = root;
//     while(a.size()){
//         if(c->child[a[0]]==NULL)
//         c->child[a[0]] = new node;
//         c = c->child[a[0]];
//         a.pop_front();
//     }
// }
// long long query(long long x)
// {
//   deque<short> a=binary(x);
//   ll ans = 0;
//   node *c = root;
//   while (a.size())
//   {
//       if(c->child[1-a[0]] != NULL){
//           c = c->child[1-a[0]];
//           ans *= 2;
//           ans += 1;
//       }else{
//           c = c->child[a[0]];
//           ans *= 2;
//       }
//       a.pop_front();
//   }
//   return ans;
//   // long long ans=0;
//   // node *C=root;
//   // while(a.size())
//   //   {
//   //     if(C->child[1-a[0]]!=NULL)
//   //     {
//   //         C=C->child[1-a[0]];
//   //         ans*=2;
//   //         ans+=1;
//   //     }
//   //     else
//   //     {
//   //         C=C->child[a[0]];
//   //         ans*=2;
//   //     }
//   //     a.pop_front();
//   //   }
//   // return ans;
// }
// ----------------- Trie --------------------------------- --- -
const int UP = 31;
const ll mod = 1e9+7;
const ll inf = 3e18*1LL;
// const int inf = 1e9+10;
// const double pi = 3.141592653589793238462643383;
const double pi = acos(-1);
const int INF = 1e9;
const int logn = 20;
const double root5 = 2.236067977;
const int N = 2e5+10;
const int lim = 1e6+10;
ll tree[4*N];
ll st[4*N];
void max_self(ll &a,ll b){
    a = max(a,b);
}
// void build(int v,int tl,int tr){
//     if(tl == tr){
//         st[v] = a[tl];
//         return;
//     }
//     int tm = (tl + tr)>1;
//     build(v+v,tl,tm);
//     build(v+v+1,tm+1,tr);
//     st[v] = max(st[v+v],st[v+v+1]);
// }
// ll get(int v,int tl,int tr,int l,int r){
//     if(tr<l || l>r || tr<l)return 0;
//     if(l<=tl || tr<=r){
//         return st[v];
//     }
//     int tm = (tl + tr)>>1;
//     return max(get(v+v,tl,tm,l,r),get(v+v+1,tm+1,tr,l,r));
// }
// void upd(int v,int tl,int tr,int l,int r,int v){
//
// }
int n;
void add_self(int &a,int b){
    a += b;
    if(a >= mod){
        a -= mod;
    }
}
int mul(int a,int b){
    return (ll)a*b%mod;
}
struct M{
    vector<vector<int> > t;
    M(){
        t.resize(n,vector<int>(n));
    }
    M operator*(const M& b) const{
        M c;
        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                for(int k=0;k<n;++k){
                    add_self(c.t[i][k],mul(t[i][j],b.t[j][k]));
                }
            }
        }
        return c;
    }
};
int main(){
    ll k;
    scanf("%d%lld",&n,&k);
    vector<vector<int> > can(n,vector<int>(n));
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            cin>>can[i][j];
        }
    }
    M answer;
    for(int i=0;i<n;++i){
        answer.t[i][i] = 1;
    }
    M m;
    m.t = can;
    while(k>0){
        if(k%2){
            answer = answer*m;
        }
        m = m*m;
        k /= 2;
    }
    int total = 0;
    for(int i=0;i<n;++i){
        for(int j=0;j<n;++j){
            add_self(total,answer.t[i][j]);
        }
    }
    cout<<total<<endl;
    return 0;
}


Measured memory_bytes: 256