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# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;

namespace AtCoder.DP
{
    class EDPC_R
    {
        public const int mod = 1000000007;

        public class Matrix
        {
            public readonly long[,] Value;

            public long this[int row, int col]
            {
                get { return Value[row, col]; }
                set { Value[row, col] = value; }
            }

            public readonly int Row;

            public readonly int Col;

            public Matrix(int row, int col)
            {
                Row = row;
                Col = col;
                Value = new long[row, col];
            }

            public Matrix(int n) : this(n, n) { }

            public void SetRow(int row, long[] value)
            {
                for (int i = 0; i < value.Length; i++)
                    Value[row, i] = value[i];
            }

            public Matrix Transpose()
            {
                var transposed = new Matrix(Col, Row);
                for (int y = 0; y < Row; y++)
                    for (int x = 0; x < Col; x++)
                        transposed[x, y] = Value[y, x];
                return transposed;
            }

            public static Matrix operator * (Matrix a, Matrix b)
            {
                var t = b.Transpose();
                var r = new Matrix(a.Row, a.Col);
                for (int y = 0; y < a.Row; y++)
                    for (int x = 0; x < a.Col; x++)
                        for (int i = 0; i < a.Col; i++)
                            r[y, x] += a[y, i] * t[x, i];
                return r;
            }

            public static Matrix Unit(int n)
            {
                var unit = new Matrix(n);
                for (int i = 0; i < n; i++)
                    unit[i, i] = 1;
                return unit;
            }

            public Matrix PowerMod(long k, long mod)
            {
                if (k == 1)
                    return this;

                var temp = PowerMod(k / 2, mod);
                var tr = temp.Transpose();

                Matrix ret = new Matrix(Row, Col);
                for (int y = 0; y < Row; y++)
                {
                    for (int x = 0; x < Col; x++)
                    {
                        for (int i = 0; i < Col; i++)
                            ret[y, x] += temp[y, i] * tr[x, i] % mod;
                        ret[y, x] %= mod;
                    }
                }

                if (k % 2 == 1)
                {
                    temp = ret;
                    tr = Transpose();
                    ret = new Matrix(Row, Col);
                    for (int y = 0; y < Row; y++)
                    {
                        for (int x = 0; x < Col; x++)
                        {
                            for (int i = 0; i < Col; i++)
                                ret[y, x] += temp[y, i] * tr[x, i] % mod;
                            ret[y, x] %= mod;
                        }
                    }
                }

                return ret;
            }
        }


        public static void Main()
        {
            var nk = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
            var n = (int)nk[0];
            var k = nk[1];

            var matrix = new Matrix(n, n);
            for (int i = 0; i < n; i++)
                matrix.SetRow(i, Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray());


            matrix = matrix.PowerMod(k, mod);

            long sum = 0;
            for (int y = 0; y < matrix.Row; y++)
                for (int x = 0; x < matrix.Col; x++)
                    sum += matrix[y, x];
            Console.WriteLine(sum % mod);
        }
    }
}