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
import java.util.Arrays;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.List;
import java.math.BigInteger;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Comparator;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author shu_mj @ http://shu-mj.com
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskE solver = new TaskE();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskE {
    Scanner in;
    PrintWriter out;

    public void solve(int testNumber, Scanner in, PrintWriter out) {
        this.in = in;
        this.out = out;
        run();
    }

    void run() {
        int n = in.nextInt();
        int k = in.nextInt();
        if (n == 1) {
            out.println(k == 0 ? 1 : 0);
            return ;
        }
        long M = (long) (1e9 + 7);
        long[][][] dp = new long[n + 1][n + 1][5];
        dp[2][0][4] = 1;
        dp[2][2][3] = 1;
        for (int i = 2; i < n; i++) {
            for (int j = 0; j <= n; j++) {
                for (int t = 0; t <= 4; t++) {
                    long ways = dp[i][j][t];
                    if (ways != 0) {
                        if (t == 4) {
                            long g = j;
                            long ng = i - 1 - g;
                            dp[i + 1][j + 2][3] += ways;
                            dp[i + 1][j + 2][3] %= M;
                            if (j - 1 >= 0) {
                                dp[i + 1][j - 1][0] += ways * g;
                                dp[i + 1][j - 1][0] %= M;
                            }
                            dp[i + 1][j][0] += ways * ng;
                            dp[i + 1][j][0] %= M;
                            dp[i + 1][j][4] += ways;
                            dp[i + 1][j][4] %= M;
                        } else {
                            dp[i + 1][j][4] += ways;
                            dp[i + 1][j][4] %= M;
                            if ((t & 1) != 0) {
                                dp[i + 1][j][2] += ways;
                                dp[i + 1][j][2] %= M;
                            } else {
                                dp[i + 1][j + 1][2] += ways;
                                dp[i + 1][j + 1][2] %= M;
                                dp[i + 1][j][0] += ways;
                                dp[i + 1][j][0] %= M;
                            }
                            if ((t & 2) != 0) {
                                dp[i + 1][j][1] += ways;
                                dp[i + 1][j][1] %= M;
                            } else {
                                dp[i + 1][j + 1][1] += ways;
                                dp[i + 1][j + 1][1] %= M;
                            }
                            long g = j - ((t & 1) != 0 ? 1 : 0) - ((t & 2) != 0 ? 1 : 0);
                            long ng = i - 2 - g - ((t & 1) != 0 ? 0 : 1);
                            if (j - 1 >= 0) {
                                dp[i + 1][j - 1][0] += ways * g;
                                dp[i + 1][j - 1][0] %= M;
                            }
                            dp[i + 1][j][0] += ways * ng;
                            dp[i + 1][j][0] %= M;
                        }
                    }
                }
            }
        }
        out.println(Algo.sum(dp[n][k]) % M);
    }
}

class Scanner {
    BufferedReader br;
    StringTokenizer st;

    public Scanner(InputStream in) {
        br = new BufferedReader(new InputStreamReader(in));
        eat("");
    }

    private void eat(String s) {
        st = new StringTokenizer(s);
    }

    public String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
            return null;
        }
    }

    public boolean hasNext() {
        while (!st.hasMoreTokens()) {
            String s = nextLine();
            if (s == null)
                return false;
            eat(s);
        }
        return true;
    }

    public String next() {
        hasNext();
        return st.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}

class Algo {


    public static long sum(long[] ls) {
        long res = 0;
        for (int i = 0; i < ls.length; i++) {
            res += ls[i];
        }
        return res;
    }

}

