#include <bits/stdc++.h>
using namespace std;
const int N = 1005, K = 2005, MOD = 998244353;
inline int add(int x, int y) {
  int res = x + y;
  if (res >= MOD) res -= MOD;
  return res;
}
inline int sub(int x, int y) { return add(x - y, MOD); }
inline int mul(int x, int y) { return (x * 1LL * y) % MOD; }
int dp[N][K][4];
int main() {
  int n, k;
  scanf("%d %d", &n, &k);
  memset(dp, sizeof(dp), 0);
  dp[1][1][0] = 1;
  dp[1][1][3] = 1;
  dp[1][2][1] = 1;
  dp[1][2][2] = 1;
  auto f = [&](int pmsk, int msk) {
    if (msk == 0 || msk == 3) return ((msk + pmsk == 3) ? 1 : 0);
    int res = 0;
    res += ((msk & 1) != (pmsk & 1));
    res += ((msk & 2) != (pmsk & 2));
    return res;
  };
  for (int i = 2; i <= n; i++) {
    for (int comp = 1; comp <= k; comp++) {
      for (int msk = 0; msk < 4; msk++) {
        for (int pmsk = 0; pmsk < 4; pmsk++) {
          int x = f(pmsk, msk);
          if (comp - x < 0) continue;
          dp[i][comp][msk] = add(dp[i][comp][msk], dp[i - 1][comp - x][pmsk]);
        }
      }
    }
  }
  int res = 0;
  for (int msk = 0; msk < 4; msk++) res = add(res, dp[n][k][msk]);
  printf("%d\n", res);
  return 0;
}

### Prompt

Please formulate a CPP solution to the following problem:

You are given a grid, consisting of 2 rows and n columns. Each cell of this grid should be colored either black or white.

Two cells are considered neighbours if they have a common border and share the same color. Two cells A and B belong to the same component if they are neighbours, or if there is a neighbour of A that belongs to the same component with B.

Let's call some bicoloring beautiful if it has exactly k components.

Count the number of beautiful bicolorings. The number can be big enough, so print the answer modulo 998244353.

Input

The only line contains two integers n and k (1 ≤ n ≤ 1000, 1 ≤ k ≤ 2n) — the number of columns in a grid and the number of components required.

Output

Print a single integer — the number of beautiful bicolorings modulo 998244353.

Examples

Input

3 4


Output

12


Input

4 1


Output

2


Input

1 2


Output

2

Note

One of possible bicolorings in sample 1:

<image>

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1005, K = 2005, MOD = 998244353;
inline int add(int x, int y) {
  int res = x + y;
  if (res >= MOD) res -= MOD;
  return res;
}
inline int sub(int x, int y) { return add(x - y, MOD); }
inline int mul(int x, int y) { return (x * 1LL * y) % MOD; }
int dp[N][K][4];
int main() {
  int n, k;
  scanf("%d %d", &n, &k);
  memset(dp, sizeof(dp), 0);
  dp[1][1][0] = 1;
  dp[1][1][3] = 1;
  dp[1][2][1] = 1;
  dp[1][2][2] = 1;
  auto f = [&](int pmsk, int msk) {
    if (msk == 0 || msk == 3) return ((msk + pmsk == 3) ? 1 : 0);
    int res = 0;
    res += ((msk & 1) != (pmsk & 1));
    res += ((msk & 2) != (pmsk & 2));
    return res;
  };
  for (int i = 2; i <= n; i++) {
    for (int comp = 1; comp <= k; comp++) {
      for (int msk = 0; msk < 4; msk++) {
        for (int pmsk = 0; pmsk < 4; pmsk++) {
          int x = f(pmsk, msk);
          if (comp - x < 0) continue;
          dp[i][comp][msk] = add(dp[i][comp][msk], dp[i - 1][comp - x][pmsk]);
        }
      }
    }
  }
  int res = 0;
  for (int msk = 0; msk < 4; msk++) res = add(res, dp[n][k][msk]);
  printf("%d\n", res);
  return 0;
}

```