#pragma GCC optimize("O3")
#include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
#include <climits>
#include <iomanip>

using namespace std;

typedef long long ll;
typedef long double ld;
#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

const int M = 1e6 + 239;
const int MOD = 998244353;
const ll MOD2 = (ll)MOD * (ll)MOD;

int mul(long long a, int b) {
    return a * b % MOD;
}

int power(int a, int b) {
    int ans = 1;
    while (b) {
        if (b & 1) ans = mul(ans, a);
        a = mul(a, a);
        b >>= 1;
    }
    return ans;
}

const int wp = power(3, 7 * 17); // w^(2^23) == 1


namespace fft {
    int k;
    vector<int> rev;
    vector<int> st;

    void fft(vector<int> &a) {
        for (int i = 0; i < k; i++)
            if (rev[i] < i)
                swap(a[rev[i]], a[i]);
        int w, wn, ai, aj;
        for (int s = 1, it = 0; s < k; s <<= 1, it++) {
            wn = st[it];
            for (int l = 0; l < k; l += s + s) {
                w = 1;
                for (int i = l, j = l + s; i < l + s; i++, j++) {
                    ai = a[i];
                    aj = 1LL * w * a[j] % MOD; // or st[((1 << 22) / s) * (i - l)]
                    a[i] = ai + aj;
                    if (a[i] >= MOD)
                        a[i] -= MOD;
                    a[j] = ai - aj;
                    if (a[j] < 0)
                        a[j] += MOD;
                    w = 1LL * w * wn % MOD;
                }
            }
        }
    }

    vector<int> mult(vector<int> a, vector<int> b) {
        k = 1;
        while (k < (int)a.size() + (int)b.size() - 1)
            k <<= 1;
        st.clear();
        st.push_back(power(wp, ((1 << 22) / k)));
        for (int t = 1; t < k; t <<= 1)
            st.push_back(1LL * st.back() * st.back() % MOD);
        reverse(st.begin(), st.end());
        rev.clear();
        rev.resize(k);
        rev[0] = 0;
        for (int i = 1; i < k; i++) {
            if (i & 1)
                rev[i] = rev[i - 1] + (k >> 1);
            else
                rev[i] = rev[i >> 1] >> 1;
        }
        a.resize(k);
        fft(a);
        b.resize(k);
        fft(b);
        vector<int> pr(k);
        for (int i = 0; i < k; i++)
            pr[i] = 1LL * a[i] * b[i] % MOD;
        fft(pr);
        reverse(pr.begin() + 1, pr.end());
        int inv_k = power(k, MOD - 2);
        for (int i = 0; i < k; i++)
            pr[i] = 1LL * pr[i] * inv_k % MOD;
        while (pr.back() == 0)
            pr.pop_back(); // can be removed
        return pr;
    }
}

int n, k;

const int MG = 15000;

const int MM = 1.1e6;

int c[MM * 2];
int dp[MM];

vector<int> values[30];
vector<pair<int, int>> cur;

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> n >> k;
    dp[0] = 0;
    cur = {{0, 1}};
    for (int i = 1; i <= n; i++)
    {
        ll sum = 0;
        for (int x = max(0, (i / 2) - k); x <= min(i - 1, (i / 2) + k); x++)
            if (abs(x - (i - x)) <= k)
            {
                sum += (ll)dp[x] * dp[i - x];
                if (sum >= MOD2)
                    sum -= MOD2;
            }
        dp[i] = ((c[i] % MOD) + (sum % MOD));
        if (dp[i] >= MOD)
            dp[i] -= MOD;
        if (dp[i] & 1)
            dp[i] += MOD;
        dp[i] /= 2;
        if (i == 1) dp[i] = 1;
//        cout << "!!!!" << dp[i] << ' ' << c[i] << ' ' << sum << '\n';
        cur.push_back({i, 1});
        while (cur.size() >= 2 && cur.back().second == cur[cur.size() - 2].second) {
            int id = cur.size() - 2;
            for (int j = 0; j < values[id].size(); ++j) {
                c[j + cur[id].first] -= values[id][j];
                if (c[j + cur[id].first] < 0) {
                    c[j + cur[id].first] += MOD;
                }
            }
            values[id].clear();
            cur[id].second <<= 1;
            cur.pop_back();
        }
        vector<int> a, b;
//        for (auto [a, b] : cur) {
//            cout << a << ' ' << b << '\n';
//        }
        for (int j = 0; j < cur.back().second * 2 && j <= i; ++j) {
            a.push_back(dp[j]);
        }
        for (int j = 0; j < cur.back().second; ++j) {
            b.push_back(dp[cur.back().first + j]);
        }
        values[cur.size() - 1] = fft::mult(a, b);
        int id = cur.size() - 1;
        if (cur.size() != 1) {
            for (auto &i : values[id]) {
                i += i;
                if (i >= MOD) {
                    i -= MOD;
                }
            }
        }
        for (int j = 0; j < values[id].size(); ++j) {
            c[j + cur[id].first] += values[id][j];
            if (c[j + cur[id].first] >= MOD) {
                c[j + cur[id].first] -= MOD;
            }
        }
//        for (auto j : values[id])cout << j << ' ';cout << '\n';
//        for (auto j : a)cout << j << '.';cout << '\n';
//        for (auto j : b)cout << j << '.';cout << '\n';
    }
    cout << dp[n] << "\n";
    cerr << TIME << "\n";
    return 0;
}