#pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"

using namespace std;

using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i32 = int32_t;
using i64 = int64_t;
constexpr char newl = '\n';

template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
//#define F first
//#define S second
#define debug(x) cout << #x << ": " << x << '\n';

#if 1

constexpr int MOD = 1e9 + 7; // 1e9 + 7

// 行列
template <class T>
class Matrix {
public:
  Matrix(int m, int n = -1, bool identityMatrix = false) {
    this->m = m;
    this->n = n >= 0 ? n : m;

    mat = vector<vector<T>>(m, vector<T>(n));
    if (identityMatrix) {
      F0R(i, m) {
        mat[i][i] = 1;
      }
    }
  }
  Matrix(const Matrix<T>& r) {
    m = r.m;
    n = r.n;
    mat = vector<vector<T>>(r.mat);
  }
  Matrix(Matrix<T>&& r) noexcept {
    // 代入と重複しているのを解決したい
    m = r.m;
    n = r.n;
    mat = move(r.mat);

    r.m = r.n = 0;
  }

  // 代入
  // ------

  Matrix<T>& operator=(Matrix<T>&& r) noexcept {
    if (this != &r) {
      // ムーブコンストラクタと重複しているのを解決したい
      m = r.m;
      n = r.n;
      mat = move(r.mat);

      r.m = r.n = 0;
    }
    return *this;
  }

  // 加法
  // ------

  Matrix<T>& operator+=(const Matrix<T>& r) {
    if (m != r.m || n != r.n) {
      throw new exception();
    }

    F0R(i, m) {
      F0R(j, n) {
        mat[i][j] += r.mat[i][j];
      }
    }

    return *this;
  }

  friend Matrix<T> operator+(Matrix<T> l, const Matrix<T>& r) {
    l += r;
    return move(l);
  }

  void SumMod(const Matrix<T>& r, int mod) {
    if (m != r.m || n != r.n) {
      throw new exception();
    }

    F0R(i, m) {
      F0R(j, n) {
        mat[i][j] += r.mat[i][j];
        if (mat[i][j] >= mod) mat[i][j] -= mod;
      }
    }
  }

  

  // スカラー倍

  // 乗法
  // ------

  friend Matrix<T> operator*(const Matrix<T>& l, const Matrix<T>& r) {
    if (l.n != r.m) throw new exception();

    Matrix<T> res(l.m, r.n);

    //       m
    // Cij = ΣAikBkj
    //       k=1
    F0R(i, l.m) {
      F0R(j, r.n) {
        F0R(k, l.n) {
          res.mat[i][j] += l.mat[i][k] * r.mat[k][j];
        }
      }
    }

    return move(res);
  }

  Matrix<T>& operator*=(const Matrix<T>& r) {

    return *this = Matrix<T>(*this * r);
  }

  static Matrix<T> MulMod(const Matrix<T>& l, const Matrix<T>& r, i64 mod) {
    if (l.n != r.m) throw new exception();

    Matrix<T> res(l.m, r.n);

    F0R(i, l.m) {
      F0R(j, r.n) {
        F0R(k, l.n) {
          res.mat[i][j] = (res.mat[i][j] + l.mat[i][k] * r.mat[k][j]) % mod;
        }
      }
    }

    return move(res);
  }



  // 累乗
  // ------

  static Matrix<T> PowMod(const Matrix<T>& v, i64 exponent, i64 mod) {

    // 行列が対角化可能であれば、計算が簡単になるらしい（wikipedia）
    // でも意味が分からないから省く…

    // 繰り返し二乗法

    if (exponent <= 0) {
      // WIP
      throw new exception();
    }

    int size = v.m;

    Matrix<T> sum(size, size, true), mul(v);

    while (exponent) {
      if (exponent & 1) {
        sum = Matrix<T>::MulMod(mul, sum, mod);
      }
      mul = Matrix<T>::MulMod(mul, mul, mod);
      exponent >>= 1;
    }

    return move(sum);
  }

  // for debug use
  void Print() {
    cout << m << "x" << n << " Matrix" << newl;
    F0R(i, m) {
      F0R(j, n) {
        cout << mat[i][j] << ' ';
      }
      cout << newl;
    }
    cout << "--------" << newl;
  }

//protected:
  int m, n;
  vector<vector<T>> mat;
};

// INSERT ABOVE HERE
signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(false);

#if 0
  // [DEBUG] Matrix test

  Matrix<int> a(2, 2), b(2, 2);

  a.mat = {
    { 5, 6},
    { 7, 8},
  };
  b.mat = {
    {1, 2},
    {3, 4},
  };

  a.Print();
  b.Print();
  (a * b).Print();
#endif

  int N;
  i64 K;
  cin >> N >> K;

  //vector<vector<int>> G(N);
  Matrix<i64> mat(N, N);

  F0R(i, N) {
    F0R(j, N) {
      //int n;
      //cin >> n;
      cin >> mat.mat[i][j];
      //if (n) G[i].push_back(j);
    }
  }

  mat = Matrix<i64>::PowMod(mat, K, MOD);

  i64 result = 0;
  F0R(i, N) {
    F0R(j, N) {
      result += mat.mat[i][j];
      if (result >= MOD) result -= MOD;
    }
  }

  cout << result;
}
#endif


Measured memory_bytes: 384