#include <bits/stdc++.h>
const long long MO = 998244353, MAXN = 2005;
const long long st00 = 0, st01 = 1, st10 = 2, st11 = 3;
long long n, k, dp[MAXN][MAXN][5];
void clean() { memset(dp, 0, sizeof dp); }
int solve() {
  clean();
  dp[1][1][st00] = dp[1][1][st11] = dp[1][2][st01] = dp[1][2][st10] = 1;
  for (long long j = 2; j <= n; j++) {
    for (long long x = 0; x <= k; x++) {
      if (x - 2 >= 0)
        dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x - 2][st10]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x - 1][st11]) % MO,
        dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x - 1][st00]) % MO;
      dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x][st01]) % MO;
      if (x - 2 >= 0)
        dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x - 2][st01]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x - 1][st11]) % MO,
        dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x - 1][st00]) % MO;
      dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x][st10]) % MO;
      dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x][st10]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x - 1][st11]) % MO;
      dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x][st01]) % MO;
      dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x][st00]) % MO;
      dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x][st10]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x - 1][st00]) % MO;
      dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x][st01]) % MO;
      dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x][st11]) % MO;
    }
  }
  printf(
      "%lld\n",
      (dp[n][k][st00] + dp[n][k][st11] + dp[n][k][st01] + dp[n][k][st10]) % MO);
  return 0;
}
int main() {
  scanf("%lld%lld", &n, &k), solve();
  return 0;
}

### Prompt

In CPP, your task is to solve 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>
const long long MO = 998244353, MAXN = 2005;
const long long st00 = 0, st01 = 1, st10 = 2, st11 = 3;
long long n, k, dp[MAXN][MAXN][5];
void clean() { memset(dp, 0, sizeof dp); }
int solve() {
  clean();
  dp[1][1][st00] = dp[1][1][st11] = dp[1][2][st01] = dp[1][2][st10] = 1;
  for (long long j = 2; j <= n; j++) {
    for (long long x = 0; x <= k; x++) {
      if (x - 2 >= 0)
        dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x - 2][st10]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x - 1][st11]) % MO,
        dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x - 1][st00]) % MO;
      dp[j][x][st01] = (dp[j][x][st01] + dp[j - 1][x][st01]) % MO;
      if (x - 2 >= 0)
        dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x - 2][st01]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x - 1][st11]) % MO,
        dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x - 1][st00]) % MO;
      dp[j][x][st10] = (dp[j][x][st10] + dp[j - 1][x][st10]) % MO;
      dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x][st10]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x - 1][st11]) % MO;
      dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x][st01]) % MO;
      dp[j][x][st00] = (dp[j][x][st00] + dp[j - 1][x][st00]) % MO;
      dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x][st10]) % MO;
      if (x - 1 >= 0)
        dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x - 1][st00]) % MO;
      dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x][st01]) % MO;
      dp[j][x][st11] = (dp[j][x][st11] + dp[j - 1][x][st11]) % MO;
    }
  }
  printf(
      "%lld\n",
      (dp[n][k][st00] + dp[n][k][st11] + dp[n][k][st01] + dp[n][k][st10]) % MO);
  return 0;
}
int main() {
  scanf("%lld%lld", &n, &k), solve();
  return 0;
}

```