#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
long long dp[4][N][N + N];
int n, k;
long long mod = 998244353;
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  cin >> n >> k;
  for (int i = 1; i <= n; i++) {
    for (int mask = 0; mask < 4; mask++) {
      for (int j = 1; j <= k; j++) {
        if (i == 1) {
          if (mask % 3 == 0) {
            if (j == 1) dp[mask][i][j] = 1;
          } else {
            if (j == 2) dp[mask][i][j] = 1;
          }
          continue;
        }
        for (int x = 0; x < 4; x++) {
          if (mask == 0) {
            if (x == 3)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else
              dp[mask][i][j] += dp[x][i - 1][j];
          } else if (mask == 1) {
            if (x == 0)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else if (x == 1)
              dp[mask][i][j] += dp[x][i - 1][j];
            else if (x == 2) {
              if (j > 1) dp[mask][i][j] += dp[x][i - 1][j - 2];
            } else
              dp[mask][i][j] += dp[x][i - 1][j - 1];
          } else if (mask == 2) {
            if (x == 0)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else if (x == 1) {
              if (j > 1) dp[mask][i][j] += dp[x][i - 1][j - 2];
            } else if (x == 2)
              dp[mask][i][j] += dp[x][i - 1][j];
            else
              dp[mask][i][j] += dp[x][i - 1][j - 1];
          } else {
            if (x == 0)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else
              dp[mask][i][j] += dp[x][i - 1][j];
          }
        }
        while (dp[mask][i][j] >= mod) dp[mask][i][j] -= mod;
      }
    }
  }
  long long ans = 0;
  for (int mask = 0; mask < 4; mask++) {
    ans = (ans + dp[mask][n][k]) % mod;
  }
  cout << ans << "\n";
  return 0;
}

### Prompt

Your task is to create 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 = 1010;
long long dp[4][N][N + N];
int n, k;
long long mod = 998244353;
int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  cin >> n >> k;
  for (int i = 1; i <= n; i++) {
    for (int mask = 0; mask < 4; mask++) {
      for (int j = 1; j <= k; j++) {
        if (i == 1) {
          if (mask % 3 == 0) {
            if (j == 1) dp[mask][i][j] = 1;
          } else {
            if (j == 2) dp[mask][i][j] = 1;
          }
          continue;
        }
        for (int x = 0; x < 4; x++) {
          if (mask == 0) {
            if (x == 3)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else
              dp[mask][i][j] += dp[x][i - 1][j];
          } else if (mask == 1) {
            if (x == 0)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else if (x == 1)
              dp[mask][i][j] += dp[x][i - 1][j];
            else if (x == 2) {
              if (j > 1) dp[mask][i][j] += dp[x][i - 1][j - 2];
            } else
              dp[mask][i][j] += dp[x][i - 1][j - 1];
          } else if (mask == 2) {
            if (x == 0)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else if (x == 1) {
              if (j > 1) dp[mask][i][j] += dp[x][i - 1][j - 2];
            } else if (x == 2)
              dp[mask][i][j] += dp[x][i - 1][j];
            else
              dp[mask][i][j] += dp[x][i - 1][j - 1];
          } else {
            if (x == 0)
              dp[mask][i][j] += dp[x][i - 1][j - 1];
            else
              dp[mask][i][j] += dp[x][i - 1][j];
          }
        }
        while (dp[mask][i][j] >= mod) dp[mask][i][j] -= mod;
      }
    }
  }
  long long ans = 0;
  for (int mask = 0; mask < 4; mask++) {
    ans = (ans + dp[mask][n][k]) % mod;
  }
  cout << ans << "\n";
  return 0;
}

```