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 <stdio.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <algorithm>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath>
#include <unordered_map>

long long pow_mod(long long x, long long n, long long mod_num) {
    long long res = 1;
    while (n > 0) {
        if (n & 1) { res = (res * x) % mod_num; }
        x = (x * x) % mod_num;
        n = (n >> 1);
    }
    return res;
}

class Combi_Num {
    public:
    long long mod_num;
    std::vector<long long> factorial, factorial_inv, inv;
    Combi_Num() {}
    Combi_Num(const int n, const long long mod_num_in) {
        mod_num = mod_num_in;
        factorial.resize(n+1, 0);
        factorial_inv.resize(n+1, 0);
        inv.resize(n+1, 0);
        factorial[0] = 1;
        factorial_inv[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = (factorial[i-1] * i) % mod_num;
            inv[i] = pow_mod(i, mod_num - 2, mod_num);
            factorial_inv[i] = (factorial_inv[i-1] * inv[i]) % mod_num;

            //std::cout << factorial[i] << " " << factorial_inv[i] << " " << inv[i] << std::endl;

        }
    }

    long long combi(const int n, const int r) {
        return (factorial[n] * ((factorial_inv[r] * factorial_inv[n-r]) % mod_num)) % mod_num;
    }

    long long perm(const int n, const int r) {
        return (factorial[n] * factorial_inv[n-r]) % mod_num;
    }
};

class BIT {
    // Binary Indexed Tree : 数列要素1つへの加算、数列のある地点までの累積和を高速に計算
    public:
    std::vector<long long> data;
    BIT() {}
    BIT(const int size) {
        // 想定されるサイズの2倍の値を入れた方がいいかもしれない。数列は1から数えることを想定している。
        data.resize(size, 0);
    }
    long long sum(int i) const {
        long long s = 0;
        while (i > 0) {
            s += data[i];
            i = i & (i-1); // iの最後のビットを引く。
        }
        return s;
    }

    void add(int i, long long x) {
        while (i < data.size()) {
            data[i] += x;
            i += i - (i & (i-1)); // iの最後のビットを加算する。
        }
    }
};

class BIT2 {
    // Binary Indexed Tree 2つ : 数列区間への加算、数列のある地点までの累積和を高速に計算。
    public:
    BIT bit[2];
    BIT2() {}
    BIT2(const int size) {
        bit[0] = BIT(size);
        bit[1] = BIT(size);
    }
    long long sum(int i) const {
        return bit[1].sum(i) * i + bit[0].sum(i);
    }
    void add(int l, int r, long long x) {
        // [l,r]にxを加算。閉区間であり、rを含む点に注意。l=rの時、一つの値のみを操作できることになる。
        bit[0].add(l, -x * (l - 1));
        bit[1].add(l, x);
        bit[0].add(r + 1, x * r);
        bit[1].add(r + 1, -x);
    }
};

const long long MOD = 998244353;
const int MAX_N = 3050;
int N, X;

Combi_Num combi_num = Combi_Num(MAX_N, MOD);
BIT2 bit2 = BIT2(MAX_N*2);

long long func12_free(int L, int sum) {
    // 長さL、総和sumの1,2配列個数。
    if (L < 0) { return 0; }

    if (L <= sum && sum <= L * 2) {
        int num2 = sum - L;
        return combi_num.combi(L, sum - L);
    } else {
        return 0;
    }
}

long long solve() {
    if (X == 1) {
        return pow_mod(2, N, MOD);
    }

    long long ret = 0;
    // 合計がX-2以下
    for (int i = 0; i <= N; i++) {
        for (int j = 0; j + i <= N; j++) {
            if (i * 2 + j <= X - 2) {
                ret += (combi_num.combi(N, i) * combi_num.combi(N - i, j)) % MOD;
                ret = ret % MOD;
            }
        }
    }

    // X-1を作ることができるが、Xを作ることができない。
    // この条件の長さLの1,2配列の数を各Lに関して計算。
    if ((X - 1) % 2 == 0) {
        // X-1が偶数のときは、全て2にする手法が(X - 1)/2以上のLについて存在。
        bit2.add((X - 1)/2, (X - 1)/2 + N, 1);
    }
    for (int p1 = 1; p1 <= N; p1++) {
        if (p1 * 2 - 1 <= X - 1) {
            for (int p2 = p1; p2 <= N; p2++) {
                // はじめて1が出てくる位置がp1、はじめて和がX-1になる位置がp2となる長さp2の数列の数をRとすると、
                // 長さp2～p2+p1-1の数列それぞれに関して、Rだけ条件を満たす数列が存在することになる。
                bit2.add(p2, p2 + p1 - 1, func12_free(p2 - p1, (X - 1) - (p1 * 2 - 1)));
                // long long の範囲を超えることは無いので、MODはとらないでおく。
            }
        }
    }

    for (int i = 1; i <= N; i++) {
        long long tmp = (bit2.sum(i) - bit2.sum(i-1)) % MOD; // 長さi、総和X-1以上、Xを作れない1,2配列の数
        ret = (ret + tmp * combi_num.combi(N, i)) % MOD;
    }
    return ret;
}


int main(int argc, char **argv) {
    std::cin >> N >> X;

    std::cout << solve() << std::endl;

    return 0;
}