#include <bits/stdc++.h>
using namespace std;

// ref: https://judge.yosupo.jp/submission/102040

template<int M> struct MINT {
    long long v;
    static MINT<M> w;
    MINT<M>() : v(0) {}
    MINT<M>(const long long v) : v(v) { normalize(); }
    void normalize() { v %= M; if (v < 0) v += M; }

    friend istream& operator >> (istream& in, MINT<M>& a) { in >> a.v; a.normalize(); return in; }
    friend ostream& operator << (ostream& out, const MINT<M>& a) { return out << a.v; }
    friend MINT<M> pow(MINT<M> a, long long b) {
        MINT<M> res = 1;
        for (; b; b >>= 1, a *= a) if (b & 1) res *= a;
        return res;
    }

    MINT<M> power(long long b) const { return pow(*this, b); }
    MINT<M> mul_inv() const { return power(M - 2); }

    MINT<M>& operator += (const MINT<M>& t) { if ((v += t.v) >= M) v -= M; return *this; }
    MINT<M>& operator -= (const MINT<M>& t) { if ((v -= t.v) < 0) v += M; return *this; }
    MINT<M>& operator *= (const MINT<M>& t) { v *= t.v; normalize(); return *this; }
    MINT<M>& operator /= (const MINT<M>& t) { *this *= t.mul_inv(); normalize(); return *this; }

    MINT<M> operator + (const MINT<M>& t) const { return MINT<M>(*this) += t; }
    MINT<M> operator - (const MINT<M>& t) const { return MINT<M>(*this) -= t; }
    MINT<M> operator * (const MINT<M>& t) const { return MINT<M>(*this) *= t; }
    MINT<M> operator / (const MINT<M>& t) const { return MINT<M>(*this) /= t; }
    MINT<M> operator - () const { return -v; }

    bool operator == (const MINT<M>& t) const { return v == t.v; }
    bool operator != (const MINT<M>& t) const { return v != t.v; }

    operator int32_t() const { return v; }
    operator int64_t() const { return v; }
};

template<int M>
void NTT(vector<MINT<M>>& a, bool inv_fft = false) {
    int n = a.size(); vector<MINT<M>> root(n / 2);
    for (int i = 1, j = 0; i < n; i++) {
        int bit = n / 2;
        while (j >= bit) j -= bit, bit >>= 1;
        if (i < (j += bit)) swap(a[i], a[j]);
    }
    auto ang = MINT<M>::w.power((M - 1) / n); if (inv_fft) ang = ang.mul_inv();
    root[0] = 1; for (int i = 1; i < n / 2; i++) root[i] = root[i - 1] * ang;
    for (int i = 2; i <= n; i <<= 1) {
        int step = n / i;
        for (int j = 0; j < n; j += i) {
            for (int k = 0; k < i / 2; k++) {
                auto u = a[j + k], v = a[j + k + i / 2] * root[k * step];
                a[j + k] = u + v; a[j + k + i / 2] = u - v;
            }
        }
    }
    auto inv = MINT<M>(n).mul_inv();
    if (inv_fft) for (int i = 0; i < n; i++) a[i] = a[i] * inv;
}

template<typename T>
struct Poly {
    vector<T> a;
    Poly() : a() {}
    Poly(T a0) : a(1, a0) { normalize(); }
    Poly(const vector<T>& a) : a(a) { normalize(); }
    void normalize() { while (!a.empty() && a.back() == T(0)) a.pop_back(); }

    int size() const { return a.size(); }
    int deg() const { return size() - 1; }
    void push_back(const T& x) { a.push_back(x); }
    T get(int idx) const { return 0 <= idx && idx < size() ? a[idx] : T(0); }
    T& operator [] (int idx) { return a[idx]; }

    Poly reversed() const { auto b = a; reverse(b.begin(), b.end()); return b; }
    Poly trim(int sz) const { return vector<T>(a.begin(), a.begin() + min(sz, size())); }
    Poly inv(int n) const {
        Poly q(T(1) / a[0]);
        for (int i = 1; i < n; i <<= 1) {
            Poly p = Poly(2) - q * trim(i * 2);
            q = (p * q).trim(i * 2);
        }
        return q.trim(n);
    }

    Poly operator *= (const T& x) { for (auto& i : a) i *= x; normalize(); return *this; }
    Poly operator /= (const T& x) { return *this *= T(1) / x; }

    Poly operator += (const Poly& t) {
        a.resize(max(size(), t.size()));
        for (int i = 0; i < t.size(); i++) a[i] += t.a[i];
        normalize(); return *this;
    }
    Poly operator -= (const Poly& t) {
        a.resize(max(size(), t.size()));
        for (int i = 0; i < t.size(); i++) a[i] -= t.a[i];
        normalize(); return *this;
    }
    Poly operator *= (const Poly& t) {
        auto b = t.a;
        int n = 2; while (n < a.size() + b.size()) n <<= 1;
        a.resize(n); b.resize(n); NTT(a); NTT(b);
        for (int i = 0; i < n; i++) a[i] *= b[i];
        NTT(a, true); normalize(); return *this;
    }
    Poly operator /= (const Poly& t) {
        if (deg() < t.deg()) return *this = Poly();
        int sz = deg() - t.deg() + 1;
        Poly ra = reversed().trim(sz), rb = t.reversed().trim(sz).inv(sz);
        *this = (ra * rb).trim(sz);
        for (int i = sz - size(); i; i--) a.push_back(T(0));
        reverse(a.begin(), a.end()); normalize();
        return *this;
    }
    Poly operator %= (const Poly& t) {
        if (deg() < t.deg()) return *this;
        Poly tmp = *this; tmp /= t; tmp *= t;
        *this -= tmp; normalize();
        return *this;
    }

    Poly operator + (const Poly& t) const { return Poly(*this) += t; }
    Poly operator - (const Poly& t) const { return Poly(*this) -= t; }
    Poly operator * (const Poly& t) const { return Poly(*this) *= t; }
    Poly operator / (const Poly& t) const { return Poly(*this) /= t; }
    Poly operator % (const Poly& t) const { return Poly(*this) %= t; }
    Poly operator * (const T x) const { return Poly(*this) *= x; }
    Poly operator / (const T x) const { return Poly(*this) /= x; }

    T eval(T x) const {
        T res = 0;
        for (int i = deg(); i >= 0; i--) res = res * x + a[i];
        return res;
    }
    Poly derivative() const {
        vector<T> res;
        for (int i = 1; i < size(); i++) res.push_back(T(i) * a[i]);
        return res;
    }
    Poly integral() const {
        vector<T> res{ T(0) };
        for (int i = 0; i < size(); i++) res.push_back(a[i] / T(i + 1));
        return res;
    }
    Poly ln(int n) const {
        assert(size() > 0 && a[0] == T(1));
        return (derivative() * inv(n)).integral().trim(n);
    }
    Poly exp(int n) const {
        if (size() == 0) return Poly(1);
        assert(size() > 0 && a[0] == T(0));
        Poly res(1);
        for (int i = 1; i < n; i <<= 1) {
            auto t = Poly(1) + trim(i * 2) - res.ln(i * 2);
            res = (res * t).trim(i * 2);
        }
        return res.trim(n);
    }
    Poly pow(long long n, int k) const {
        // compute f(x)^n mod x^k
        Poly acc(1), t = *this;
        t = t.trim(k);
        for (; n; n >>= 1) {
            if (n & 1) acc = (acc * t).trim(k);
            t = (t * t).trim(k);
        }
        return acc;
    }
};

using ModInt = MINT<998244353>;
template<> ModInt ModInt::w = ModInt(3);

using T = ModInt;


const int MAX_SIZE = 1 << 20;
int N, K;

vector<ModInt> T_array(MAX_SIZE);

void DnC(int l, int r) {
    if (l + 1 == r) {
        if (l <= 1) {
            T_array[l] = l;
        }
        else {
            if (l % 2 == 0) {
                T_array[l] -= T_array[l / 2] * T_array[l / 2];
            }
            T_array[l] /= 2;
            int curr_i = (l + 1) / 2;
            while (curr_i < l && (2 * curr_i - l) <= K) {
                T_array[l] += T_array[curr_i] * T_array[l - curr_i];
                ++curr_i;
            }
        }
        return;
    }
    int m = l + r >> 1;
    DnC(l, m);
    vector<ModInt> A(T_array.begin() + l, T_array.begin() + m);
    int len1 = min(m, r - l);
    int len2 = min(l, r - l);
    vector<ModInt> B(T_array.begin(), T_array.begin() + len1);
    vector<ModInt> C(T_array.begin(), T_array.begin() + len2);
    Poly<ModInt> PA(A), PB(B), PC(C);
    Poly<ModInt> prod1 = PA * PB;
    Poly<ModInt> prod2 = PA * PC;
    for (int offset = m - l; offset < r - l; ++offset) {
        if (prod1.size() > offset) {
            T_array[offset + l] += prod1[offset];
        }
        if (prod2.size() > offset) {
            T_array[offset + l] += prod2[offset];
        }
    }
    DnC(m, r);
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    cin >> N >> K;

    DnC(0, MAX_SIZE);

    cout << T_array[N] << '\n';

    return 0;
}