#include <bits/stdc++.h>

/* -------------------------------- Template -------------------------------- */

#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()

using namespace std;

using ll = long long;
using ld = long double;

template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }

template<typename T> T inf() { assert(false); }
template<> constexpr int inf<int>() { return 1e9; }
template<> constexpr ll inf<ll>() { return 1e18; }
template<> constexpr ld inf<ld>() { return 1e30; }

/* -------------------------------- Library -------------------------------- */

template<int M>
class Cyclic {
  using ll = long long;
  int n;
  static ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p); }
public:
  Cyclic () : n(0) {;}
  Cyclic (int m) : n(m) {
    if (n >= M) n %= M;
    else if (n < 0) n = (n % M + M) % M;
  }
  operator int() const { return n; }
  bool operator==(const Cyclic &a) const { return n == a.n; }
  Cyclic operator+=(const Cyclic &a) { n += a.n; if (n >= M) n -= M; return *this; }
  Cyclic operator-=(const Cyclic &a) { n -= a.n; if (n < 0) n += M; return *this; }
  Cyclic operator*=(const Cyclic &a) { n = (ll(n) * a.n) % M; return *this; }
  Cyclic operator+(const Cyclic &a) const { Cyclic res = *this; return res += a; }
  Cyclic operator-(const Cyclic &a) const { Cyclic res = *this; return res -= a; }
  Cyclic operator*(const Cyclic &a) const { Cyclic res = *this; return res *= a; }
  Cyclic operator/(const Cyclic &a) const { return *this * Cyclic<M>(inv(a, M)); }
  Cyclic operator^(int n) const {
    if (n == 0) return Cyclic(1);
    const Cyclic a = *this;
    Cyclic res = (a * a) ^ (n / 2);
    return n % 2 ? res * a : res;
  }
};

template<int M> Cyclic<M> fact(int n, bool sw = true) {
  static vector<Cyclic<M>> v1 = {1}, v2 = {1};
  if (n >= (int)v1.size()) {
    const int from = v1.size(), to = n + 1024;
    v1.reserve(to);
    v2.reserve(to);
    for (int i = from; i < to; ++i) {
      v1.push_back(v1.back() * Cyclic<M>(i));
      v2.push_back(v2.back() / Cyclic<M>(i));
    }
  }
  return sw ? v1[n] : v2[n];
}

template<int M> Cyclic<M> comb(int a, int b) {
  return fact<M>(a, true) * fact<M>(b, false) * fact<M>(a-b, false);
}

const int mod = 924844033;
using Mod = Cyclic<mod>;

/* ---------------------------------- Main ---------------------------------- */

Mod dp0[2048][2048], dp1[2048][2048], dp2[2048][2048];
Mod dp[2048][2048];

int main() {
  int N, K;
  cin >> N >> K;
  dp1[0][0] = 1; dp2[0][0] = 1;
  for (int i = 0; i < 2030; ++i) {
    for (int j = 0; j < 2030; ++j) {
      dp0[i+1][j+1] += dp0[i][j];
      dp0[i+1][j] += dp1[i][j];
      dp1[i+1][j+1] += dp1[i][j];
      dp1[i+1][j] += dp2[i][j];
      dp2[i+1][j+1] += dp2[i][j] + dp1[i][j];
      dp2[i+1][j] += dp2[i][j];
    }
  }
  int kmax = min(2 * K, N);
  vector<vector<int>> vec(kmax);
  REP(i,N) vec[i % (K * 2)].push_back(i);
  vector<int> type(kmax, 0);
  vector<int> len(kmax);
  REP(i,kmax) {
    if (!vec[i].empty()) {
      if (vec[i].front() - K >= 0) ++type[i];
      if (vec[i].back() + K < N) ++type[i];
    }
    len[i] = vec[i].size();
  }
  dp[0][0] = 1;
  // REP(i,2) cout << dp1[1][i] << " "; cout << endl;
  REP(i,kmax) REP(j,N+1) REP(k,len[i]+1) {
    Mod val;
    if (type[i] == 0)      val = dp0[len[i]][k];
    else if (type[i] == 1) val = dp1[len[i]][k];
    else                   val = dp2[len[i]][k];
    dp[i+1][j+k] += dp[i][j] * val;
  }
  // REP(i,N+1) cout << dp[kmax][i] << " "; cout << endl;
  Mod res = 0;
  REP(i,N+1) {
    if (i % 2) res -= dp[kmax][i] * fact<mod>(N-i);
    else res += dp[kmax][i] * fact<mod>(N-i);
  }
  cout << res << endl;
  return 0;
}


Measured memory_bytes: 65920