#include <bits/stdc++.h>
#define endl '\n'

using namespace std;
template<class T, class T2> inline void chkmax(T &x, const T2 &y) { if(x < y) x = y; }
template<class T, class T2> inline void chkmin(T &x, const T2 &y) { if(x > y) x = y; }
const double PI = acos(-1);
const int MAXN = (1 << 19);
int mod = 924844033;

inline void addmod(int& x, int y, int mod) { (x += y) >= mod && (x -= mod); }
inline int mulmod(int x, int y, int mod) { return x * 1ll * y % mod; }

struct complex_base
{
	long double x, y;
	complex_base(long double _x = 0, long double _y = 0) { x = _x; y = _y; }
	friend complex_base operator-(const complex_base &a, const complex_base &b) { return complex_base(a.x - b.x, a.y - b.y); }
	friend complex_base operator+(const complex_base &a, const complex_base &b) { return complex_base(a.x + b.x, a.y + b.y); }
	friend complex_base operator*(const complex_base &a, const complex_base &b) { return complex_base(a.x * b.x - a.y * b.y, a.y * b.x + b.y * a.x); }
	friend void operator/=(complex_base &a, const long double &P) { a.x /= P; a.y /= P; }
};

int bit_rev[MAXN];

void fft(complex_base *a, int lg)
{
	int n = (1 << lg);
	for(int i = 1; i < n; i++)
	{
		bit_rev[i] = (bit_rev[i >> 1] >> 1) | ((i & 1) << (lg - 1));
		if(bit_rev[i] < i) swap(a[i], a[bit_rev[i]]);
	}

	for(int len = 2; len <= n; len <<= 1)
	{
		long double ang = 2 * PI / len;
		complex_base w(1, 0), wn(cos(ang), sin(ang));
		for(int j = 0; j < (len >> 1); j++, w = w * wn)
			for(int i = 0; i < n; i += len)
			{
				complex_base u = a[i + j], v = w * a[i + j + (len >> 1)];
				a[i + j] = u + v;
				a[i + j + (len >> 1)] = u - v;
			}
	}
}

void inv_fft(complex_base *a, int lg)
{
	int n = (1 << lg);
	for(int i = 1; i < n; i++)
	{
		bit_rev[i] = (bit_rev[i >> 1] >> 1) | ((i & 1) << (lg - 1));
		if(bit_rev[i] < i) swap(a[i], a[bit_rev[i]]);
	}

	for(int len = 2; len <= n; len <<= 1)
	{
		long double ang = -2 * PI / len;
		complex_base w(1, 0), wn(cos(ang), sin(ang));

		for(int j = 0; j < (len >> 1); j++, w = w * wn)
			for(int i = 0; i < n; i += len)
			{
				complex_base u = a[i + j], v = w * a[i + j + (len >> 1)];
				a[i + j] = u + v;
				a[i + j + (len >> 1)] = u - v;
			}
	}

	for(int i = 0; i < n; i++)
		a[i] /= n;
}

complex_base A[MAXN], B[MAXN];

vector<int> mult(const vector<int> &a, const vector<int> &b)
{
	if(a.size() * b.size() <= 128)
	{
		vector<int> ans(a.size() + b.size(), 0);
		for(int i = 0; i < (int)a.size(); i++)
			for(int j = 0; j < (int)b.size(); j++)
				ans[i + j] = (ans[i + j] + a[i] * 1ll * b[j]) % mod;

		return ans;
	}

	int lg = 0; while((1 << lg) < (int)(a.size() + b.size())) ++lg;
	for(int i = 0; i < (1 << lg); i++) A[i] = B[i] = complex_base(0, 0);
	for(int i = 0; i < (int)a.size(); i++) A[i] = complex_base(a[i], 0);
	for(int i = 0; i < (int)b.size(); i++) B[i] = complex_base(b[i], 0);

	fft(A, lg); fft(B, lg);
	for(int i = 0; i < (1 << lg); i++)
		A[i] = A[i] * B[i];
	inv_fft(A, lg);

	vector<int> ans(a.size() + b.size(), 0);
	for(int i = 0; i < (int)ans.size(); i++)
		ans[i] = (int64_t)(A[i].x + 0.5) % mod;

	return ans;
}

vector<int> mult_mod(const vector<int> &a, const vector<int> &b)
{
	/// Thanks pavel.savchenkov

	// a = a0 + sqrt(MOD) * a1
	// a = a0 + base * a1
	int base = (int)sqrtl(mod);

	vector<int> a0(a.size()), a1(a.size());
	for(int i = 0; i < (int)a.size(); i++) 
	{
		a0[i] = a[i] % base;
		a1[i] = a[i] / base;
	}

	vector<int> b0(b.size()), b1(b.size());
	for(int i = 0; i < (int)b.size(); i++)
	{
		b0[i] = b[i] % base;
		b1[i] = b[i] / base;
	}

	vector<int> a01 = a0;
	for(int i = 0; i < (int)a.size(); i++) 
		addmod(a01[i], a1[i], mod);  	

	vector<int> b01 = b0;
	for(int i = 0; i < (int)b.size(); i++) 
		addmod(b01[i], b1[i], mod);

	vector<int> C = mult(a01, b01);  // 1

	vector<int> a0b0 = mult(a0, b0); // 2
	vector<int> a1b1 = mult(a1, b1); // 3

	vector<int> mid = C;
	for(int i = 0; i < (int)mid.size(); i++) 
	{
		addmod(mid[i], -a0b0[i] + mod, mod);
		addmod(mid[i], -a1b1[i] + mod, mod);
	}

	vector<int> res = a0b0;
	for(int i = 0; i < (int)res.size(); i++)
		addmod(res[i], mulmod(base, mid[i], mod), mod);

	base = mulmod(base, base, mod);
	for(int i = 0; i < (int)res.size(); i++)
		addmod(res[i], mulmod(base, a1b1[i], mod), mod);

	return res;
}

int pw(int x, int p)
{
	int ret = 1;
	while(p)
	{
		if(p & 1) ret = (ret * 1ll * x) % mod;
		x = (x * 1ll * x) % mod;
		p >>= 1;
	}

	return ret;
}

int inv(int x) { return pw(x, mod - 2); }

int n, k;

void read()
{
	cin >> n >> k;
}

int fact[MAXN], inv_fact[MAXN];

int comb(int n, int k)
{
	if(k < 0 || n < k) return 0;
	return (((fact[n] * 1ll * inv_fact[k]) % mod) * 1ll * inv_fact[n - k]) % mod;
}

vector<vector<int> > initial_list; 

vector<int> rec(int l, int r)
{
	if(l == r) return initial_list[l];

	int mid = (l + r) >> 1;
	vector<int> a, b, ret;

	a = rec(l, mid);
	b = rec(mid + 1, r);
	ret = mult_mod(a, b);

	while(ret.size() > a.size() + b.size()) ret.pop_back();
	return ret;
}

void solve()
{
	fact[0] = 1;
	for(int i = 1; i <= n; i++) fact[i] = (fact[i - 1] * 1ll * i) % mod;
	inv_fact[n] = inv(fact[n]);
	for(int i = n - 1; i >= 0; i--)
		inv_fact[i] = (inv_fact[i + 1] * 1ll * (i + 1)) % mod;

	for(int st = 0; st < 2 * k; st++)
	{
		int cnt_edges = 0, cnt = 0;
		for(int p = st; p < n; p += 2 * k) 
		{
			cnt++; 
			if(p - k >= 0) cnt_edges++;
			if(p + k < n) cnt_edges++;
		}

		vector<int> curr(cnt + 1, 0);
		for(int c = 0; c <= cnt; c++) 
			curr[c] = comb(cnt_edges - c + 1, c);

		initial_list.push_back(curr);
	}

	vector<int> answer_poly = rec(0, (int)initial_list.size() - 1);
	int answer = 0; 

	for(int c = 0; c <= n; c++)
	{
		int cnt = (answer_poly[c] * 1ll * fact[n - c]) % mod;
		if(c & 1) answer = (answer + mod - cnt) % mod;
		else answer = (answer + cnt) % mod;
	}

	cout << answer << endl;
}

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	read();
	solve();
	return 0;
}



Measured memory_bytes: 37632