Problem:
Score : 100 points

Problem Statement

There is a simple directed graph G with N vertices, numbered 1, 2, \ldots, N.

For each i and j (1 \leq i, j \leq N), you are given an integer a_{i, j} that represents whether there is a directed edge from Vertex i to j.
If a_{i, j} = 1, there is a directed edge from Vertex i to j; if a_{i, j} = 0, there is not.

Find the number of different directed paths of length K in G, modulo 10^9 + 7.
We will also count a path that traverses the same edge multiple times.

Constraints

All values in input are integers.

1 \leq N \leq 50

1 \leq K \leq 10^{18}

a_{i, j} is 0 or 1.

a_{i, i} = 0

Input

Input is given from Standard Input in the following format:

N K
a_{1, 1} \ldots a_{1, N}
:
a_{N, 1} \ldots a_{N, N}

Output

Print the number of different directed paths of length K in G, modulo 10^9 + 7.

Sample Input 1

4 2
0 1 0 0
0 0 1 1
0 0 0 1
1 0 0 0

Sample Output 1

6

G is drawn in the figure below:

There are six directed paths of length 2:

1 → 2 → 3

1 → 2 → 4

2 → 3 → 4

2 → 4 → 1

3 → 4 → 1

4 → 1 → 2

Sample Input 2

3 3
0 1 0
1 0 1
0 0 0

Sample Output 2

3

G is drawn in the figure below:

There are three directed paths of length 3:

1 → 2 → 1 → 2

2 → 1 → 2 → 1

2 → 1 → 2 → 3

Sample Input 3

6 2
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
0 0 0 0 1 0
0 0 0 0 0 1
0 0 0 0 0 0

Sample Output 3

1

G is drawn in the figure below:

There is one directed path of length 2:

4 → 5 → 6

Sample Input 4

1 1
0

Sample Output 4

0

Sample Input 5

10 1000000000000000000
0 0 1 1 0 0 0 1 1 0
0 0 0 0 0 1 1 1 0 0
0 1 0 0 0 1 0 1 0 1
1 1 1 0 1 1 0 1 1 0
0 1 1 1 0 1 0 1 1 1
0 0 0 1 0 0 1 0 1 0
0 0 0 1 1 0 0 1 0 1
1 0 0 0 1 0 1 0 0 0
0 0 0 0 0 1 0 0 0 0
1 0 1 1 1 0 1 1 1 0

Sample Output 5

957538352

Be sure to print the count modulo 10^9 + 7.

Solution in C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

# pragma GCC optimize("Ofast")
# pragma GCC target("avx,avx2,fma")
# pragma GCC optimization ("unroll-loops")
# include <bits/stdc++.h>
std::pair<int,int> DR[] = {{-1,0},{0,1},{1,0},{0,-1},{-1,1},{-1,-1},{1,1},{1,-1}};
# define ll long long
# define clock (clock() * 1000.0 / CLOCKS_PER_SEC)
# define rc(s) return cout << s,0
# define rcg(s) cout << s;exit(0)
# define _ ios_base::sync_with_stdio(false);cin.tie(0);cerr.tie(0);cout.tie(0);
# define db(x) cerr << #x << " = " << x << '\n'
# define pb push_back
# define mp make_pair
# define all(s) s.begin(),s.end()
# define sz(x) (int)((x).size())
# define int ll
using namespace std;
int gcd(int a, int b)
{
    if(b) return gcd(b,a%b);
    return a;
}mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const int mod = 1e9 + 7;

int n,k;
int dp[70][55][55];
int a[55][55];
int ans[70][55][55];
int answer,alter;

int32_t main(){_
    //freopen("in","r",stdin);
	cin >> n >> k;
	for(int i = 1;i <= n;i++)
	{
		for(int j = 1;j <= n;j++)
		{
			cin >> a[i][j];
			if(a[i][j] == 1)
			{
				dp[0][i][j] = 1;
				if(k & 1) {
					ans[0][i][j] = 1;
					alter++;
				}
			}
		}
	}
	if(k == 1) rc(alter);
	bool b = 0;
	if(k & 1) b = 1;
	for(int f = 1;f < 62;f++)
	{
		for(int l = 1;l <= n;l++)
		{
			for(int r = 1;r <= n;r++)
			{
				for(int mid = 1;mid <= n;mid++)
				{
					dp[f][l][r] += (dp[f - 1][l][mid] * dp[f - 1][mid][r]) % mod;
					dp[f][l][r] %= mod;
				}
			}
		}
		if(!b)
		{
			if(k & (1 << f)){
				b = 1;
				for(int l = 1;l <= n;l++)
				{
					for(int r = 1;r <= n;r++)
					{
						ans[f][l][r] = dp[f][l][r];
					}
				}
			}
			else continue;
		}
		for(int l = 1;l <= n;l++)
		{
			for(int r = 1;r <= n;r++)
			{
				if(k & (1LL << f)) {
					for(int mid = 1;mid <= n;mid++)
					{
						ans[f][l][r] += (ans[f - 1][l][mid] * dp[f][mid][r]) % mod;
						ans[f][l][r] %= mod;
					}
				}
				else ans[f][l][r] = ans[f - 1][l][r];
				if(f == 61)
				{
					answer += ans[f][l][r];
					answer %= mod;
				}
			}
		}
	}
	rc(answer);
}