#include <bits/stdc++.h>
using namespace std;

#define EPS 1e-10
#define MOD 1000000007

template<typename T> class mat : public vector<vector<T>> {
private:
  int r, c;
public:
  inline int row() const {
    return r;
  }
  inline int column() const {
    return c;
  }
  mat(int n, int m, T val = 0) {
    r = n, c = m;
    for (int i = 0; i < n; i++) {
      this -> push_back(vector<T>(m, val));
    }
  }
  mat operator + (const mat &another) const {
    mat<T> X(r, c);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        X.at(i).at(j) = (*this).at(i).at(j) + another.at(i).at(j);
      }
    }
    return X;
  }
  mat operator + (const T val) const {
    mat<T> X(r, c);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        X.at(i).at(j) = (*this).at(i).at(j) + val;
      }
    }
    return X;
  }
  mat operator - (const mat &another) const {
    mat<T> X(r, c);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        X.at(i).at(j) = (*this).at(i).at(j) - another.at(i).at(j);
      }
    }
    return X;
  }
  mat operator - (const T val) const {
    mat<T> X(r, c);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        X.at(i).at(j) = (*this).at(i).at(j) - val;
      }
    }
    return X;
  }
  vector<T> operator * (const vector<T> &another) const {
    vector<T> vec(r, 0);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        vec.at(i) += (*this).at(i).at(j) * another.at(j);
      }
    }
    return vec;
  }
  mat operator * (const mat &another) const {
    mat<T> X(r, another.c);
    for (int i = 0; i < r; i++) {
      for (int k = 0; k < c; k++) {
        for (int j = 0; j < (another.c); j++) {
          X.at(i).at(j) += (*this).at(i).at(k) * another.at(k).at(j);
        }
      }
    }
    return X;
  }
  mat operator - () const {
    mat<T> X(r, c);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        X.at(i).at(j) = -(*this).at(i).at(j);
      }
    }
    return X;
  }
  int rank() const {
    int res = 0;
    mat B(r, c);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        B.at(i).at(j) = (*this).at(i).at(j);
      }
    }
    for (int i = 0; i < c; i++) {
      if (res == r) return res;
      int pivot = res;
      for (int j = res + 1; j < r; j++) {
        if (abs(B.at(j).at(i)) > abs(B.at(pivot).at(i))) {
          pivot = j;
        }
      }
      if (abs(B.at(pivot).at(i)) < EPS) continue;
      swap(B.at(pivot), B.at(res));
      for (int j = i + 1; j < c; j++) {
        B.at(res).at(j) /= B.at(res).at(i);
      }
      for (int j = res + 1; j < r; j++) {
        for (int k = i + 1; k < c; k++) {
          B.at(j).at(k) -= B.at(res).at(k) * B.at(j).at(i);
        }
      }
      res++;
    }
    return res;
  }
  T det() const {
    T ans = 1;
    mat B(r, r);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < c; j++) {
        B.at(i).at(j) = (*this).at(i).at(j);
      }
    }
    for (int i = 0; i < c; i++) {
      int pivot = i;
      for (int j = i + 1; j < r; j++) {
        if (abs(B.at(j).at(i)) > abs(B.at(pivot).at(i))) {
          pivot = j;
        }
      }
      if (abs(B.at(pivot).at(i)) < EPS) return (T)0;
      if (pivot != i) swap(B.at(i), B.at(pivot)), ans = -ans;
      ans *= B.at(i).at(i);
      for (int j = i + 1; j < r; j++) {
        for (int k = c - 1; k >= i; k--) {
          B.at(j).at(k) -= B.at(i).at(k) * B.at(j).at(i) / B.at(i).at(i);
        }
      }
    }
    return ans;
  }
  mat inverse() const {
    mat B(r, 2 * r);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < r; j++) {
        B.at(i).at(j) = (*this).at(i).at(j);
      }
    }
    for (int i = 0; i < r; i++) {
      B.at(i).at(r + i) = 1;
    }
    for (int i = 0; i < r; i++) {
      int pivot = i;
      for (int j = i; j < r; j++) {
        if (abs(B.at(j).at(i)) > abs(B.at(pivot).at(i))) {
          pivot = j;
        }
      }
      swap(B.at(i), B.at(pivot));
      for (int j = i + 1; j < 2 * r; j++) {
        B.at(i).at(j) /= B.at(i).at(i);
      }
      for (int j = 0; j < r; j++) {
        if (i != j) {
          for (int k = i + 1; k < 2 * r; k++) {
            B.at(j).at(k) -= B.at(j).at(i) * B.at(i).at(k);
          }
        }
      }
    }
    mat res(r, r);
    for (int i = 0; i < r; i++) {
      for (int j = 0; j < r; j++) {
        res.at(i).at(j) = B.at(i).at(r + j);
      }
    }
    return res;
  }
};

template<typename T> vector<T> eq_solve(const mat<T> &A, const vector<T> &b) {
  int n = A.row();
  mat<T> B(n, n + 1);
  for (int i = 0; i < n; i++) {
    for (int j = 0; j < n; j++) {
      B.at(i).at(j) = A.at(i).at(j);
    }
  }
  for (int i = 0; i < n; i++) {
    B.at(i).at(n) = b.at(i);
  }
  for (int i = 0; i < n; i++) {
    int pivot = i;
    for (int j = i; j < n;j++) {
      if (abs(B.at(j).at(i)) > abs(B.at(pivot).at(i))) {
        pivot = j;
      }
    }
    swap(B.at(i), B.at(pivot));
    for (int j = i + 1; j <= n; j++) {
      B.at(i).at(j) /= B.at(i).at(i);
    }
    for (int j = 0; j < n; j++) {
      if (i != j) {
        for (int k = i + 1; k <= n; k++) {
          B.at(j).at(k) -= B.at(j).at(i) * B.at(i).at(k);
        }
      }
    }
  }
  vector<T> res(n);
  for (int i = 0; i < n; i++) {
    res.at(i) = B.at(i).at(n);
  }
  return res;
}

template<typename T> mat<T> pow(mat<T> A, long cnt) {
  int n = A.row();
  mat<T> B(n, n);
  for (int i = 0; i < n; i++) {
    B.at(i).at(i) = 1;
  }
  while (cnt > 0) {
    if (cnt & 1) B = B * A;
    A = A * A;
    cnt >>= 1;
  }
  return B;
}

template<typename T> mat<T> mod_mul(mat<T> &A, mat<T> &B) {
  mat<T> X(A.row(), B.column());
  for (int i = 0; i < A.row(); i++) {
    for (int k = 0; k < A.column(); k++) {
      for (int j = 0; j < B.column(); j++) {
        X.at(i).at(j) = (X.at(i).at(j) + (long) A.at(i).at(k) * B.at(k).at(j)) % MOD;
      }
    }
  }
  return X;
}

template<typename T> mat<T> mod_pow(mat<T> A, long cnt) {
  int n = A.row();
  mat<T> B(n, n);
  for (int i = 0; i < n; i++) {
    B.at(i).at(i) = 1;
  }
  while (cnt > 0) {
    if (cnt & 1) B = mod_mul(B, A);
    A = mod_mul(A, A);
    cnt >>= 1;
  }
  return B;
}

int main() {
  int N;
  long K;
  cin >> N >> K;
  mat<int> M(N, N);
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
      cin >> M.at(i).at(j);
    }
  }
  mat<int> M2 = mod_pow(M, K);
  long ans = 0;
  for (int i = 0; i < N; i++) {
    for (int j = 0; j < N; j++) {
      ans += M2.at(i).at(j);
      ans %= MOD;
    }
  }
  cout << ans << "\n";
}

Measured memory_bytes: 3680