Find the number, modulo 998244353, of sequences of length N consisting of 0, 1 and 2 such that none of their contiguous subsequences totals to X.

Constraints

* 1 \leq N \leq 3000
* 1 \leq X \leq 2N
* N and X are integers.

Input

Input is given from Standard Input in the following format:


N X


Output

Print the number, modulo 998244353, of sequences that satisfy the condition.

Examples

Input

3 3


Output

14


Input

8 6


Output

1179


Input

10 1


Output

1024


Input

9 13


Output

18402


Input

314 159


Output

459765451
#include <bits/stdc++.h>

using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }

#ifdef LOCAL
#define show(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl
#else
#define show(x) true
#endif

template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
    return os << "P(" << p.first << ", " << p.second << ")";
}

template <class T> ostream& operator<<(ostream& os, const V<T>& v) {
    os << "[";
    for (auto d : v) os << d << ", ";
    return os << "]";
}

template <uint MD> struct ModInt {
    using M = ModInt;
    const static M G;
    uint v;
    ModInt(ll _v = 0) { set_v(_v % MD + MD); }
    M& set_v(uint _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    explicit operator bool() const { return v != 0; }
    M operator-() const { return M() - *this; }
    M operator+(const M& r) const { return M().set_v(v + r.v); }
    M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    M operator*(const M& r) const { return M().set_v(ull(v) * r.v % MD); }
    M operator/(const M& r) const { return *this * r.inv(); }
    M& operator+=(const M& r) { return *this = *this + r; }
    M& operator-=(const M& r) { return *this = *this - r; }
    M& operator*=(const M& r) { return *this = *this * r; }
    M& operator/=(const M& r) { return *this = *this / r; }
    bool operator==(const M& r) const { return v == r.v; }
    M pow(ll n) const {
        M x = *this, r = 1;
        while (n) {
            if (n & 1) r *= x;
            x *= x;
            n >>= 1;
        }
        return r;
    }
    M inv() const { return pow(MD - 2); }
    friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};
using Mint = ModInt<998244353>;
template<> const Mint Mint::G = Mint(3);

const int MN = 3030;
Mint fact[10000], iFac[10000];

Mint C(int n, int k) {
    if (n < k || k < 0) return Mint(0);
    return fact[n] * iFac[k] * iFac[n - k];
}

Mint dp[MN][2 * MN];

void first() {
    fact[0] = 1;
    for (int i = 1; i < 10000; i++) {
        fact[i] = fact[i - 1] * i;
    }
    for (int i = 0; i < 10000; i++) {
        iFac[i] = fact[i].inv();
    }
    dp[0][0] = Mint(1);
    for (int i = 1; i < MN; i++) {
        for (int j = 0; j < 2 * MN; j++) {
            dp[i][j] += dp[i - 1][j];
            if (j - 1 >= 0) dp[i][j] += dp[i - 1][j - 1];
            if (j - 2 >= 0) dp[i][j] += dp[i - 1][j - 2];
        }
    }
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);

    first();

    int n, x;
    cin >> n >> x;

    Mint sm = 0;
    for (int i = 0; i <= x - 1; i++) sm += dp[n][i];

    for (int c = 1; x - 1 - 2 * c >= 0 && n - 2 * c >= 0; c++) {
        int n2 = n - 2 * c;
        for (int i = 0; i <= n2; i++) {
            sm += dp[i][x - 1 - 2 * c] * C(n2 - i + 2 * c - 1, 2 * c - 1);
        }
    }

    if (x % 2) {
        for (int he = x; he <= n; he++) {
            sm += C(n, he);
        }
    }
    cout << sm << endl;

    return 0;
}