Sereja is interested in intervals of numbers, so he has prepared a problem about intervals for you. An interval of numbers is a pair of integers [l, r] (1 ≤ l ≤ r ≤ m). Interval [l1, r1] belongs to interval [l2, r2] if the following condition is met: l2 ≤ l1 ≤ r1 ≤ r2.

Sereja wants to write out a sequence of n intervals [l1, r1], [l2, r2], ..., [ln, rn] on a piece of paper. At that, no interval in the sequence can belong to some other interval of the sequence. Also, Sereja loves number x very much and he wants some (at least one) interval in the sequence to have li = x. Sereja wonders, how many distinct ways to write such intervals are there?

Help Sereja and find the required number of ways modulo 1000000007 (109 + 7).

Two ways are considered distinct if there is such j (1 ≤ j ≤ n), that the j-th intervals in two corresponding sequences are not equal.

Input

The first line contains integers n, m, x (1 ≤ n·m ≤ 100000, 1 ≤ x ≤ m) — the number of segments in the sequence, the constraints on the numbers in segments and Sereja's favourite number.

Output

In a single line print the answer modulo 1000000007 (109 + 7).

Examples

Input

1 1 1


Output

1


Input

3 5 1


Output

240


Input

2 3 3


Output

6

Note

In third example next sequences will be correct: {[1, 1], [3, 3]}, {[1, 2], [3, 3]}, {[2, 2], [3, 3]}, {[3, 3], [1, 1]}, {[3, 3], [2, 2]}, {[3, 3], [1, 2]}.
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 321, MOD = 1e9 + 7;
int64_t dp[2][NMAX][NMAX];
int64_t tdp[2][NMAX][NMAX];
int main() {
  ios::sync_with_stdio(false);
  int n, m, x;
  cin >> n >> m >> x;
  if (n > m) {
    cout << "0\n";
    return 0;
  }
  dp[0][0][0] = tdp[0][0][0] = 1;
  for (int i = 1, u = 1; i <= m; ++i, u ^= 1) {
    for (int j = 0; j <= n; ++j) {
      for (int k = 0; k <= n; ++k) {
        dp[u][j][k] = dp[u ^ 1][j][k];
        tdp[u][j][k] = tdp[u ^ 1][j][k];
      }
    }
    for (int j = 0; j <= n; ++j) {
      for (int k = 0; k <= n; ++k) {
        if (j > 0) {
          dp[u][j][k] += dp[u ^ 1][j - 1][k + 1];
          tdp[u][j][k] += tdp[u ^ 1][j - 1][k + 1];
        }
        if (k > 0) {
          if (i != x) {
            dp[u][j][k] += dp[u ^ 1][j][k - 1];
          }
          tdp[u][j][k] += tdp[u ^ 1][j][k - 1];
        }
        if (j > 0) {
          if (i != x) {
            dp[u][j][k] += dp[u ^ 1][j - 1][k];
          }
          tdp[u][j][k] += tdp[u ^ 1][j - 1][k];
        }
        dp[u][j][k] %= MOD;
        tdp[u][j][k] %= MOD;
      }
    }
  }
  int ans = (tdp[m & 1][n][0] - dp[m & 1][n][0]) % MOD;
  for (int i = 1; i <= n; ++i) {
    ans = (int64_t)ans * i % MOD;
  }
  if (ans < 0) ans += MOD;
  cout << ans << '\n';
}
