矩阵快速幂

const int MOD = 1e9 + 7;

struct Matrix{
    typedef long long T;
    typedef unsigned long long ull;
	int r,c;
	vector<vector<T>> a;
	Matrix(int _r = 0,int _c = 0):r(_r),c(_c){
        a.assign(r,vector<T>(c,0));
	};
	vector<T> &operator[](int idx){return a[idx];}
	const vector<T> &operator[](int idx)const{return a[idx];}
	Matrix operator*(const Matrix &rhs){
		assert(c==rhs.r);
		Matrix ret(r,rhs.c);
        for(int i = 0;i < r;i++){
            for(int j = 0;j < rhs.c;j++){
                for(int k = 0;k < c;k++){
                    ret[i][j] = (ret[i][j] + a[i][k] * rhs[k][j]) % MOD;
                }
            }
        }
		return ret;
	}
	Matrix trans(){
		Matrix ret(r,c);
        for(int i = 0;i < r;i++){
            for(int j = 0;j < c;j++){
                ret[j][i] = ret[i][j];
            }
        }
		return ret;
	}
	Matrix unit(){
		assert(r==c);
		Matrix ret(r,r);
		for(int i = 0;i < r;i++){
            ret[i][i] = 1;
        }
		return ret;
	}
	Matrix pow(ull k){
		Matrix base=*this,ret=unit(); 
        while(k){
            if(k & 1) ret = ret * base;
            base = base * base;
            k >>= 1;
        }
        return ret;
	}
};

class Solution {
public:
    int lengthAfterTransformations(string s, int t, vector<int>& nums) {
        Matrix fast(26,26),base(26,1);
        for(int i = 0;i < 26;i++)base[i][0] = 1;
        for(int i = 0;i < nums.size();i++){
            for(int j = i + 1;j < i + nums[i] + 1;j++){
                fast[i][j % 26] = 1;
            }
        }
        Matrix ret  = fast.pow(t) * base;
        long long ans = 0;
        for(int i = 0;i < s.size();i++){
            ans = (ans + ret[s[i] - 'a'][0]) % MOD;
        }
        return ans;
    }
};

#include <iostream>
#include <istream>
#include <sstream>
#include <vector>
#include <stack>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <cstring>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <numeric>
#include <chrono>
#include <ctime>
#include <cmath>
#include <cctype>
#include <string>
#include <cstdio>
#include <iomanip>


#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
#include <iterator>
using namespace std;

inline int read(int& x) {
	char ch = getchar();
	int f = 1; x = 0;
	while (ch > '9' || ch < '0') { if (ch == '-')f = -1; ch = getchar(); }
	while (ch >= '0' && ch <= '9') { x = (x << 1) + (x << 3) + ch - '0'; ch = getchar(); }
	return x * f;
}

const int MOD = 1e9 + 7;
long long int n,m;

struct Matrix {
	int a[202][202];
	Matrix() { memset(a, 0, sizeof(a)); }

	void Init() {
		for (int i = 0; i < n; i++)a[i][i] = 1;
	}

	Matrix operator*(const Matrix& input)const {
		Matrix ret;
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				for (int k = 0; k < n; k++) {
					ret.a[i][j] = (ret.a[i][j] + (long long int)a[i][k] * input.a[k][j]) % MOD;
				}
			}
		}
		return ret;
	}
	void Input() {
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				cin >> a[i][j];
			}
		}
	}
	void OutPut() {
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < n; j++) {
				cout << a[i][j] << " ";
			}
			cout << endl;
		}
	}
}A, res;

void quickPow(long long int k) {
	res.Init();
	while (k) {
		if (k & 1) res = res * A;
		A = A * A;
		k >>= 1;
	}
	res.OutPut();
}

int main()
{
	cin >> n >> m;
	A.Input();
	quickPow(m);
	return 0;
}