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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include "iostream"
#include "algorithm"
#include "vector"
#include "string"
#include "cmath"
typedef long long ll;
using namespace std;

int main(int argc, char const *argv[]) {
  ll KK, HH, WW;

  ll div = 1e9 + 7;
  // std::cout << div << '\n';

  std::cin >> HH >> WW >> KK;

  ll trans[WW][WW];

  for (size_t i = 0; i < WW; i++) {
    for (size_t j = 0; j < WW; j++) {
      trans[i][j] = 0;
    }
  }

  for (size_t i = 0; i < WW; i++) {
    for (size_t i2 = i; i2 < WW; i2++) {
      if (i > 0 && i2 - i <2) {
        continue;
      }
      for (size_t i3 = i2; i3 < WW; i3++) {
        if (i2 > 0 && i3 -i2 < 2) {
          continue;
        }
        // #valid check
        // std::cout << "i::"<<i<<"  i2::"<<i2<<"  i3::"<<i3 << '\n';


        int sss[WW];
        for (size_t j = 0; j < WW; j++) {
          sss[j] = j;
        }



        if (i != 0) {
          int temp = sss[i-1];
          sss[i-1] = sss[i];
          sss[i] = temp;
        }
        if (i2 != 0) {
          int temp = sss[i2-1];
          sss[i2-1] = sss[i2];
          sss[i2] = temp;
        }
        if (i3 != 0) {
          int temp = sss[i3-1];
          sss[i3-1] = sss[i3];
          sss[i3] = temp;
        }

        for (size_t j = 0; j < WW; j++) {
          trans[j][sss[j]] += 1;
        }

      }
    }
  }

  // for (size_t i = 0; i < WW; i++) {
  //   for (size_t j = 0; j < WW; j++) {
  //     std::cout << trans[i][j] << ' ';
  //   }
  //   std::cout  << '\n';
  // }

  ll ans_dence[WW];
  // for (size_t i = 0; i < WW; i++) {
  //   ans_dence[i] = 1;
  // }
  ans_dence[0] = 1;
  for (size_t i = 1; i < WW; i++) {
    ans_dence[i] = 0;
  }

  for (size_t i = 0; i < HH; i++) {
    ll ans_dence_next[WW];
    for (size_t hh = 0; hh < WW; hh++) {
      ans_dence_next[hh] = 0;
    }
    for (size_t j = 0; j < WW; j++) {
      ll ans_dence_j = 0;
      for (size_t j2 = 0; j2 < WW; j2++) {
        ans_dence_j = (trans[j][j2] * ans_dence[j2] + ans_dence_j) % div;
      }
      ans_dence_next[j] = ans_dence_j;
    }
    for (size_t gg = 0; gg < WW; gg++) {
      ans_dence[gg] = ans_dence_next[gg];
    }
  }

  // for (size_t i = 0; i < WW; i++) {
  //   std::cout << ans_dence[i] << '\n';
  // }

  std::cout << ans_dence[KK-1] << '\n';


  return 0;
}