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 <cstdio>

using namespace std;

const int mod = 998244353;

long long c[3001][3001];
int dp[3001][6001][2];
int dp2[3001][3001];
int dp3[3001][3001];
int dp4[3001][3001];
int dp5[6001][2];

int main() {
    int n, x, i, j, k;
    long long ans = 0;
    
    scanf("%d %d", &n, &x);
    
    for (i = 0; i <= n; i++) {
        c[i][0] = c[i][i] = 1;
        for (j = 1; j < i; j++) {
            c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
            if (c[i][j] >= mod) c[i][j] -= mod;
        }
    }
    
    dp[1][1][1] = 1;
    for (i = 1; i < n; i++) {
        for (j = 0; j <= n * 2; j++) {
            for (k = 0; k < 2; k++) {
                if (dp[i][j][k] == 0) continue;
                
                dp[i + 1][j + 2][0] += dp[i][j][k];
                if (dp[i + 1][j + 2][0] >= mod) dp[i + 1][j + 2][0] -= mod;
                
                dp[i + 1][j + 1][1] += dp[i][j][k];
                if (dp[i + 1][j + 1][1] >= mod) dp[i + 1][j + 1][1] -= mod;
            }
        }
    }
    
    for (i = 1; i <= n; i++) {
        for (j = 1; j < x; j++) {
            if (j % 2 == x % 2) continue;
            if (dp[i][j][1] == 0) continue;
            
            dp2[i][(x - j) / 2] += dp[i][j][1];
            if (dp2[i][(x - j) / 2] >= mod) dp2[i][(x - j) / 2] -= mod;
        }
    }
    
    for (i = 1; i <= n; i++) {
        for (j = 0; j <= n; j++) {
            if (dp2[i][j] == 0) continue;
            
            dp3[i][j] += dp2[i][j];
            if (dp3[i][j] >= mod) dp3[i][j] -= mod;
            
            if (i + j + 1 <= n) {
                dp3[i + j + 1][j] -= dp2[i][j];
                if (dp3[i + j + 1][j] < 0) dp3[i + j + 1][j] += mod;
            }
        }
    }
    
    for (i = 1; i <= n; i++) {
        for (j = 0; j <= n; j++) {
            dp3[i][j] += dp3[i - 1][j];
            if (dp3[i][j] >= mod) dp3[i][j] -= mod;
        }
    }
    
    for (i = 1; i <= n; i++) {
        for (j = 0; j <= n; j++) {
            if (dp3[i][j] == 0) continue;
            
            dp4[i][j] += dp3[i][j];
            if (dp4[i][j] >= mod) dp4[i][j] -= mod;
            
            if (i + j + 1 <= n) {
                dp4[i + j + 1][j] -= dp3[i][j];
                if (dp4[i + j + 1][j] < 0) dp4[i + j + 1][j] += mod;
            }
        }
    }
    
    for (i = 1; i <= n; i++) {
        for (j = 0; j <= n; j++) {
            dp4[i][j] += dp4[i - 1][j];
            if (dp4[i][j] >= mod) dp4[i][j] -= mod;
        }
    }
    
    dp5[0][0] = 1;
    for (i = 0; i < n; i++) {
        for (j = i * 2; j >= 0; j--) {
            for (k = 0; k < 2; k++) {
                if (dp5[j][k] == 0) continue;
                
                dp5[j + 2][k] += dp5[j][k];
                if (dp5[j + 2][k] >= mod) dp5[j + 2][k] -= mod;
                
                dp5[j + 1][1] += dp5[j][k];
                if (dp5[j + 1][1] >= mod) dp5[j + 1][1] -= mod;
            }
        }
    }
    
    if (x % 2 == 0) {
        for (i = 0; i < x / 2; i++) {
            ans += c[n][i];
            if (ans >= mod) ans -= mod;
        }
    } else {
        for (i = 0; i <= n; i++) {
            ans += c[n][i];
            if (ans >= mod) ans -= mod;
        }
    }
    
    for (i = 1; i <= n; i++) {
        for (j = 0; j <= n; j++) {
            if (dp4[i][j] == 0) continue;
            
            ans += dp4[i][j] * c[n][i] % mod;
            if (ans >= mod) ans -= mod;
        }
    }
    
    for (i = 0; i < x; i++) {
        if (i % 2 == x % 2) {
            ans += dp5[i][1];
            if (ans >= mod) ans -= mod;
        }
    }
    
    printf("%lld\n", ans);
    
    return 0;
}
