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 i64 = long long;

long long *fact, *inv;

template <class T>
T pow(T x, T n, T mod) {
    T ret = 1;
    while(n > 0) {
        if ((n & 1) == 1) ret = (ret * x) % mod;
        x = (x * x) % mod;
        n >>= 1;
    }
    return ret;
}

template <class T>
T inverse(T x, T p) { return pow(x, p - 2, p); }

void init_factorial(int n, long long mod) {
    fact = new long long[n + 1];
    inv = new long long[n + 1];
    fact[0] = 1;
    for (long long i = 1; i <= n; i++) fact[i] = fact[i - 1] * i % mod;
    inv[n] = inverse(fact[n], mod);
    for (long long i = n; i > 0; i--) inv[i - 1] = inv[i] * i % mod;
}

int main() {
    i64 n, x;
    constexpr i64 mod = 998244353;
    std::cin >> n >> x;
    init_factorial(n, mod);
    std::vector<std::vector<i64>> dp(n + 1, std::vector<i64>(2 * n + 10));
    dp[0][0] = 1;
    for (int i = 1; i <= n; i++) for (int j = 0; j <= 2 * n; j++) {
        dp[i][j + 1] = (dp[i][j + 1] + dp[i - 1][j]) % mod;
        dp[i][j + 2] = (dp[i][j + 2] + dp[i - 1][j]) % mod;
    }
    i64 ret = 0;
    for (int i = 0; i <= n; i++) for (int j = 0; j < x; j++) {
        ret = (ret + dp[i][j] * fact[n] % mod * inv[i] % mod * inv[n - i] % mod) % mod;
    }
    for (int i = 1; i * 2 <= x - 1; i++) for (int j = i; j + i <= n; j++) {
        ret = (ret + dp[j - i][x - i * 2 - 1] * fact[n] % mod * inv[j + i] % mod * inv[n - j - i] % mod) % mod;
    }
    if (x % 2) {
        for (int i = x; i <= n; i++) {
            ret = (ret + fact[n] * inv[i] % mod * inv[n - i] % mod) % mod;
        }
    }
    std::cout << ret << std::endl;

    return 0;
}
