Problem: Snuke loves permutations. He is making a permutation of length N.

Since he hates the integer K, his permutation will satisfy the following:

* Let the permutation be a_1, a_2, ..., a_N. For each i = 1,2,...,N, |a_i - i| \neq K.



Among the N! permutations of length N, how many satisfies this condition?

Since the answer may be extremely large, find the answer modulo 924844033(prime).

Constraints

* 2 ≦ N ≦ 2000
* 1 ≦ K ≦ N-1

Input

The input is given from Standard Input in the following format:


N K


Output

Print the answer modulo 924844033.

Examples

Input

3 1


Output

2


Input

4 1


Output

5


Input

4 2


Output

9


Input

4 3


Output

14


Input

425 48


Output

756765083

Solution (in CPP):

Solution:
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>

#define For(i, j, k) for(int i = j; i <= k; i++)
#define Forr(i, j, k) for(itn i = j; i >= k; i--)

using namespace std;

const int N = 2010;
const int Mod = 924844033;

typedef long long LL;

int n, k, A[N];
bool flag[N];
LL dp[N][N][2][2];

int main(){
	scanf("%d%d", &n, &k);
	dp[0][0][0][0] = 1;
	int o = 0;
	For(i, 0, n) flag[i] = true;
	For(i, 1, n % k) flag[o += n / k + 1] = false;
	while(o < n) flag[o += n / k] = false;
	For(i, 0, n)
		For(j, 0, i) For(u, 0, 1) For(v, 0, 1){
			LL val = dp[i][j][u][v];
			if(j) (dp[i + 1][j - 1][0][0] += val * (j - flag[i] * u) * (j - flag[i] * v)) %= Mod;
			(dp[i + 1][j][0][0] += val) %= Mod;
			(dp[i + 1][j][0][1] += val * (j - flag[i] * u)) %= Mod;
			(dp[i + 1][j][1][0] += val * (j - flag[i] * v)) %= Mod;
			(dp[i + 1][j + 1][1][1] += val) %= Mod;
		}
	printf("%lld\n", dp[n][0][0][0]);
	return 0;
}