Problem:
Score: 400 points

Problem Statement

Amidakuji is a traditional method of lottery in Japan.

To make an amidakuji, we first draw W parallel vertical lines, and then draw horizontal lines that connect them. The length of each vertical line is H+1 [cm], and the endpoints of the horizontal lines must be at 1, 2, 3, ..., or H [cm] from the top of a vertical line.

A valid amidakuji is an amidakuji that satisfies the following conditions:

No two horizontal lines share an endpoint.

The two endpoints of each horizontal lines must be at the same height.

A horizontal line must connect adjacent vertical lines.

Find the number of the valid amidakuji that satisfy the following condition, modulo 1\ 000\ 000\ 007: if we trace the path from the top of the leftmost vertical line to the bottom, always following horizontal lines when we encounter them, we reach the bottom of the K-th vertical line from the left.

For example, in the following amidakuji, we will reach the bottom of the fourth vertical line from the left.

Constraints

H is an integer between 1 and 100 (inclusive).

W is an integer between 1 and 8 (inclusive).

K is an integer between 1 and W (inclusive).

Input

Input is given from Standard Input in the following format:

H W K

Output

Print the number of the amidakuji that satisfy the condition, modulo 1\ 000\ 000\ 007.

Sample Input 1

1 3 2

Sample Output 1

1

Only the following one amidakuji satisfies the condition:

Sample Input 2

1 3 1

Sample Output 2

2

Only the following two amidakuji satisfy the condition:

Sample Input 3

2 3 3

Sample Output 3

1

Only the following one amidakuji satisfies the condition:

Sample Input 4

2 3 1

Sample Output 4

5

Only the following five amidakuji satisfy the condition:

Sample Input 5

7 1 1

Sample Output 5

1

As there is only one vertical line, we cannot draw any horizontal lines. Thus, there is only one amidakuji that satisfies the condition: the amidakuji with no horizontal lines.

Sample Input 6

15 8 5

Sample Output 6

437760187

Be sure to print the answer modulo 1\ 000\ 000\ 007.

Solution in Rust (1.42.0) (judge verdict: Accepted)

#![allow(
    non_snake_case,
    unused_variables,
    unused_assignments,
    unused_mut,
    unused_imports,
    dead_code
)]
//use proconio::fastout;
use proconio::input;
use proconio::marker::*;
//use std::collections::HashSet;
// use std::cmp::*;
use std::collections::*;

const MOD: i64 = 1_000_000_007_i64;
fn main() {
    input! {
       H:usize,W:usize,K:Usize1
    }
    if W == 1 {
        println!("1");
        return;
    }
    // ある高さhで、 wとw+1の間を移動した時、
    // 0..w-1の間とw+2..Wの間の棒の存在は自由。
    // 同様に、移動しなかった時
    // 0..w-1の間とw+1..Wの間の棒の存在は自由
    // 縦棒は高々8本。
    let mut free_bars = HashMap::new();
    let fib = |x| match x {
        0 => 1,
        1 => 1,
        2 => 2,
        3 => 3,
        4 => 5,
        5 => 8,
        6 => 13,
        7 => 21,
        8 => 34,
        _ => 1,
    };
    for w in 0..W {
        // w -> w
        free_bars.insert((w, w), fib(w) * fib(W - w - 1));
        if w < W - 1 {
            free_bars.insert((w, w + 1), fib(w) * fib(W - w - 2));
        }
    }
    // 以上、準備
    // 縦棒がW本なので、隙間はW-1かしょ。
    // 上から h cm の位置で、移動前後の位置をペアで表す。
    // H回の遷移で、0からKまで移動する必要がある。
    let mut mv = vec![(0, 0); H];
    // 通過するバーを下記のように表す。
    let mut l = vec![vec![0; W]; H];
    // h 回目の移動後に位置wにいるパターン数をdpとする。
    let mut dp = vec![vec![0; W]; H];
    dp[0][0] = *free_bars.get(&(0, 0)).unwrap();
    dp[0][1] = *free_bars.get(&(0, 1)).unwrap();
    for h in 1..H {
        for w in 0..W {
            if w > 0 {
                dp[h][w] += dp[h - 1][w - 1] * *free_bars.get(&(w - 1, w)).unwrap();
            }
            dp[h][w] += dp[h - 1][w] * *free_bars.get(&(w, w)).unwrap();
            if w < W - 1 {
                dp[h][w] += dp[h - 1][w + 1] * *free_bars.get(&(w, w + 1)).unwrap();
            }
            dp[h][w] = dp[h][w] % MOD;
        }
    }
    //println!("{:?}", dp);
    println!("{}", dp[H - 1][K]);
}