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>
const int oo = 2139063143;
const int N = 1100;
const int P = 1000000007;
using namespace std;
inline void sc(int &x) {
  x = 0;
  static int p;
  p = 1;
  static char c;
  c = getchar();
  while (!isdigit(c)) {
    if (c == '-') p = -1;
    c = getchar();
  }
  while (isdigit(c)) {
    x = (x << 1) + (x << 3) + (c - 48);
    c = getchar();
  }
  x *= p;
}
inline void print(int x) {
  if (x < 0) putchar('-'), x = -x;
  if (x >= 10) print(x / 10);
  putchar(x % 10 + '0');
}
inline void pr(int x) { print(x), putchar('\n'); }
int del(int x) { return x >= P ? x - P : x; }
int C[N][N], jc[N];
void init(int n) {
  C[0][0] = 1;
  for (int i = 1; i <= n; i++) {
    C[i][0] = 1;
    for (int j = 1; j <= i; j++) C[i][j] = del(C[i - 1][j] + C[i - 1][j - 1]);
  }
  jc[0] = 1;
  for (int i = 1; i <= n; i++) jc[i] = (long long)i * jc[i - 1] % P;
}
int f[N][N][2][2], ans[N];
int main() {
  int n, m;
  sc(n), sc(m);
  init(n + 5);
  f[0][0][1][0] = 1;
  for (int i = 1; i <= n; i++)
    for (int j = 0; j < i; j++)
      for (int k = 0; k <= 1; k++)
        for (int l = 0; l <= 1; l++) {
          f[i][j][l][0] = del(f[i][j][l][0] + f[i - 1][j][k][l]);
          if (!k)
            f[i][j + 1][l][0] = del(f[i][j + 1][l][0] + f[i - 1][j][k][l]);
          if (i < n)
            f[i][j + 1][l][1] = del(f[i][j + 1][l][1] + f[i - 1][j][k][l]);
        }
  for (int i = 0; i <= n; i++) {
    for (int j = 0; j <= 1; j++)
      for (int k = 0; k <= 1; k++) ans[i] = del(ans[i] + f[n][i][j][k]);
    ans[i] = (long long)ans[i] * jc[n - i] % P;
  }
  int an = 0;
  for (int i = m; i <= n; i++) {
    int g = (long long)ans[i] * C[i][m] % P;
    if ((i - m) & 1) g = P - g;
    an = del(an + g);
  }
  pr(an);
  return 0;
}
