#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void amax(X& x, const Y& y) {
  if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
  if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = (long long)1e18 + 10;
const int MOD = 998244353;
const int MAX = 1010;
struct item {
  int ms1, ms2, d;
};
const item items[] = {{0, 0, 0}, {0, 1, 1}, {0, 2, 1}, {0, 3, 1},
                      {1, 0, 0}, {1, 1, 0}, {1, 2, 2}, {1, 3, 0},
                      {2, 0, 0}, {2, 1, 2}, {2, 2, 0}, {2, 3, 0},
                      {3, 0, 1}, {3, 1, 1}, {3, 2, 1}, {3, 3, 0}};
const int abc[] = {0, 1, 1, 1, 0, 0, 2, 0, 0, 2, 0, 0, 1, 1, 1, 0};
int n, k;
int f[MAX][2 * MAX][4];
int add(int a, int b) { return (a + b) % MOD; }
int dist(int ms1, int ms2) { return abc[ms1 * 4 + ms2]; }
void process() {
  cin >> n >> k;
  f[1][1][0] = f[1][1][3] = 1;
  f[1][2][1] = f[1][2][2] = 1;
  for (int i = 1; i < n; i++)
    for (int j = 1; j <= 2 * i; j++)
      for (int ms1 = 0; ms1 < 4; ms1++) {
        for (int ms2 = 0; ms2 < 4; ms2++) {
          f[i + 1][j + dist(ms1, ms2)][ms2] =
              add(f[i + 1][j + dist(ms1, ms2)][ms2], f[i][j][ms1]);
        }
      }
  int res = 0;
  for (int ms = 0; ms < 4; ms++) res = add(res, f[n][k][ms]);
  cout << res;
}
int main() {
  ios_base::sync_with_stdio(false);
  process();
}

### Prompt

Generate 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;
template <class X, class Y>
void amax(X& x, const Y& y) {
  if (x < y) x = y;
}
template <class X, class Y>
void amin(X& x, const Y& y) {
  if (x > y) x = y;
}
const int INF = 1e9 + 10;
const long long INFL = (long long)1e18 + 10;
const int MOD = 998244353;
const int MAX = 1010;
struct item {
  int ms1, ms2, d;
};
const item items[] = {{0, 0, 0}, {0, 1, 1}, {0, 2, 1}, {0, 3, 1},
                      {1, 0, 0}, {1, 1, 0}, {1, 2, 2}, {1, 3, 0},
                      {2, 0, 0}, {2, 1, 2}, {2, 2, 0}, {2, 3, 0},
                      {3, 0, 1}, {3, 1, 1}, {3, 2, 1}, {3, 3, 0}};
const int abc[] = {0, 1, 1, 1, 0, 0, 2, 0, 0, 2, 0, 0, 1, 1, 1, 0};
int n, k;
int f[MAX][2 * MAX][4];
int add(int a, int b) { return (a + b) % MOD; }
int dist(int ms1, int ms2) { return abc[ms1 * 4 + ms2]; }
void process() {
  cin >> n >> k;
  f[1][1][0] = f[1][1][3] = 1;
  f[1][2][1] = f[1][2][2] = 1;
  for (int i = 1; i < n; i++)
    for (int j = 1; j <= 2 * i; j++)
      for (int ms1 = 0; ms1 < 4; ms1++) {
        for (int ms2 = 0; ms2 < 4; ms2++) {
          f[i + 1][j + dist(ms1, ms2)][ms2] =
              add(f[i + 1][j + dist(ms1, ms2)][ms2], f[i][j][ms1]);
        }
      }
  int res = 0;
  for (int ms = 0; ms < 4; ms++) res = add(res, f[n][k][ms]);
  cout << res;
}
int main() {
  ios_base::sync_with_stdio(false);
  process();
}

```