Permutation p is an ordered set of integers p1, p2, ..., pn, consisting of n distinct positive integers, each of them doesn't exceed n. We'll denote the i-th element of permutation p as pi. We'll call number n the size or the length of permutation p1, p2, ..., pn.

We'll call position i (1 ≤ i ≤ n) in permutation p1, p2, ..., pn good, if |p[i] - i| = 1. Count the number of permutations of size n with exactly k good positions. Print the answer modulo 1000000007 (109 + 7).

Input

The single line contains two space-separated integers n and k (1 ≤ n ≤ 1000, 0 ≤ k ≤ n).

Output

Print the number of permutations of length n with exactly k good positions modulo 1000000007 (109 + 7).

Examples

Input

1 0


Output

1


Input

2 1


Output

0


Input

3 2


Output

4


Input

4 1


Output

6


Input

7 4


Output

328

Note

The only permutation of size 1 has 0 good positions.

Permutation (1, 2) has 0 good positions, and permutation (2, 1) has 2 positions.

Permutations of size 3:

  1. (1, 2, 3) — 0 positions
  2. <image> — 2 positions
  3. <image> — 2 positions
  4. <image> — 2 positions
  5. <image> — 2 positions
  6. (3, 2, 1) — 0 positions
#include <bits/stdc++.h>
using ll = long long;
int const N = 1e3 + 5;
int const K = 504;
ll dp[K][K][3];
ll binom[N][N];
ll fact[N];
ll res[N];
ll atres[N];
int n, k;
int const P = 1e9 + 7;
void calc_bin(int n) {
  for (int i = 0; i <= n; i++) {
    binom[i][0] = 1;
    for (int j = 1; j <= i; j++) {
      binom[i][j] = (binom[i - 1][j] + binom[i - 1][j - 1]) % P;
    }
  }
}
void calc_dp(int n) {
  dp[0][0][0] = 1;
  dp[0][0][1] = 1;
  dp[0][0][2] = 1;
  for (int i = 1; i <= n; i++) {
    dp[i][0][0] = 1;
    dp[i][0][1] = 1;
    dp[i][0][2] = 1;
    if (i == 1) {
      dp[1][1][0] = 0;
      dp[1][1][1] = 1;
      dp[1][1][2] = 2;
      continue;
    }
    for (int j = 1; j <= i; j++) {
      dp[i][j][0] = (dp[i - 1][j][1] + dp[i - 1][j - 1][0]) % P;
      dp[i][j][1] = (dp[i][j][0] + dp[i - 1][j - 1][1]) % P;
      dp[i][j][2] =
          (dp[i - 1][j - 1][2] + dp[i - 1][j][2] + dp[i - 1][j - 1][1]) % P;
    }
  }
}
void factorial(int n) {
  fact[0] = 1;
  for (int i = 1; i <= n; i++) {
    fact[i] = (fact[i - 1] * i) % P;
  }
}
void calc_res(int n) {
  int u = (n + 1) / 2;
  int w = n / 2;
  for (int i = 0; i <= n; i++) {
    for (int j = std::max(0, i - w); j <= std::min(i, u + 1); j++) {
      res[i] = (res[i] + dp[u][j][(u == w)] * dp[w][i - j][(u > w) + 1]) % P;
    }
  }
}
int main() {
  scanf("%d %d", &n, &k);
  calc_bin(n);
  calc_dp(n / 2 + 2);
  factorial(n);
  calc_res(n);
  for (int i = n; i >= k; i--) {
    res[i] = (res[i] * fact[n - i]) % P;
    atres[i] = res[i];
    for (int j = i + 1; j <= n; j++) {
      ll w = ((j % 2 == i % 2) ? 1 : P - 1);
      w = (w * binom[j][i]) % P;
      w = (w * res[j]) % P;
      atres[i] = (atres[i] + w) % P;
    }
  }
  printf("%I64d", atres[k]);
  return 0;
}
