#ifdef LOCAL
#include <local.hpp>
#else
#pragma GCC optimize("O3")
// #pragma target("arch=skylake-avx512")
#include <bits/stdc++.h>
#define debug(...) ((void)0)
#endif

#include <atcoder/modint.hpp>
using mint = atcoder::modint998244353;
namespace atcoder {
template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
std::ostream& operator<<(std::ostream& os, const static_modint<m>& x) {
    return os << x.val();
}
}  // namespace atcoder

using namespace std;
using ll = long long;
using ld = long double;

void solve(int) {
    int N, K;
    cin >> N >> K;

    // dp[i][j][k] := i 番目までで j 本使って、i+1との関係が下の k になっているパスの数
    // (0)        (1)        (2)        (3)        (4)
    //    o ->       o          o          o ->     ↗ o ->
    //    |          |          |          |       |  |
    //    o          o ->       o        ↙ o <-     ↖ o <-
    //    |          |          |       |  |          |
    //    o          o          o ->     ↘ o ->       o ->
    vector dp(N + 1, vector(K + 3, vector<mint>(5, 0)));

    // 列 1
    dp[1][0][0] = 1;
    dp[1][0][1] = 1;
    dp[1][0][2] = 1;
    dp[1][0][3] = 1;
    dp[1][0][4] = 0;

    auto cost = [](int i, int row) {
        if (i % 2) {
            return (row != 3 ? 1 : 0);
        }
        return (row != 1 ? 1 : 0);
    };

    // i -> i+1
    for (int i = 1; i < N; i++) {
        for (int j = 0; j <= K; j++) {
            // (0) から
            dp[i + 1][j + cost(i, 1)][0] += dp[i][j][0];
            dp[i + 1][j + cost(i, 1)][1] += dp[i][j][0];
            dp[i + 1][j + cost(i, 1)][2] += dp[i][j][0];
            dp[i + 1][j + cost(i, 1)][3] += dp[i][j][0];

            // (1) から
            dp[i + 1][j + 1][0] += dp[i][j][1];
            dp[i + 1][j + 1][1] += dp[i][j][1];
            dp[i + 1][j + 1][2] += dp[i][j][1];

            // (2) から
            dp[i + 1][j + cost(i, 3)][0] += dp[i][j][2];
            dp[i + 1][j + cost(i, 3)][1] += dp[i][j][2];
            dp[i + 1][j + cost(i, 3)][2] += dp[i][j][2];
            dp[i + 1][j + cost(i, 3)][4] += dp[i][j][2];

            // (3) から
            dp[i + 1][j + 2][2] += dp[i][j][3];
            dp[i + 1][j + 2][3] += dp[i][j][3];

            // (4) から
            dp[i + 1][j + 2][0] += dp[i][j][4];
            dp[i + 1][j + 2][4] += dp[i][j][4];
        }
    }

    mint ans = 0;
    for (int j = 0; j <= K; j++) {
        ans += dp[N][j][(N % 2 ? 2 : 0)];
    }
    cout << ans << endl;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    // cin >> t;
    for (int i = 1; i <= t; i++) {
        solve(i);
    }

#ifdef LOCAL
    postprocess();
#endif
}