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 Rust (1.15.1) (judge verdict: Accepted)

use std::error::Error;
use std::io;

pub fn main() {
    if let Err(_e) = run() {
        panic!("failed");
    }
}

fn run() -> Result<(), Box<Error>> {
    let mut input = String::new();
    io::stdin().read_line(&mut input);
    let line: Vec<i64> = input
        .trim()
        .split_whitespace()
        .map(|s| s.parse::<i64>().unwrap())
        .collect();
    let n = line[0];
    let k = line[1];
    input.clear();
    let mut edges = Vec::new();
    for _ in 0..n {
        io::stdin().read_line(&mut input)?;
        let line: Vec<i64> = input
            .trim()
            .split_whitespace()
            .map(|s| s.parse::<i64>().unwrap())
            .collect();
        edges.push(line);
        input.clear();
    }
    let result = solve(&edges, k, n);
    let mut sum = 0;
    for i in 0..n as usize {
        for j in 0..n as usize {
            sum += result[i][j];
            sum %= 1_000_000_007;
        }
    }
    println!("{:?}", sum);
    Ok(())
}

fn solve(edges: &Vec<Vec<i64>>, k: i64, n: i64) -> Vec<Vec<i64>> {
    if k == 1 {
        return edges.clone();
    }
    let pow = solve(edges, k / 2, n);
    if k % 2 == 1 {
        return multiply(edges, &multiply(&pow, &pow, n), n);
    }
    return multiply(&pow, &pow, n);
}

fn multiply(a: &Vec<Vec<i64>>, b: &Vec<Vec<i64>>, n: i64) -> Vec<Vec<i64>> {
    let mut result = vec![vec![0; n as usize]; n as usize];
    for i in 0..n as usize {
        for j in 0..n as usize {
            let mut sum = 0;
            for k in 0..n as usize {
                sum += a[i][k] * b[k][j];
                sum %= 1_000_000_007;
            }
            result[i][j] = sum;
        }
    }
    result
}