#include <bits/stdc++.h>
using namespace std;
double const EPS = 1e-12, PI = acos(-1);
const int N = 2e3 + 9, M = 1e6 + 9, OO = 1e9 + 7, MOD = 1e9 + 7,
          MOD2 = 998244353;
const long long INF = 2e18;
int mem[N][N][3][3], n, k;
int add(long long x, int y) {
  x += y;
  while (x >= MOD2) x -= MOD2;
  while (x < 0) x += MOD2;
  return x;
}
int solve(int idx, int connected, int prv1, int prv2) {
  if (idx + 1 == n) return connected == k;
  if (connected > k) return 0;
  int& ret = mem[idx][connected][prv1][prv2];
  if (~ret) return ret;
  ret = 0;
  for (int i = 0; i < 2; ++i) {
    bool can = (prv1 != i) && (prv2 != i);
    ret = add(ret, solve(idx + 1, connected + can, i, i));
  }
  for (int i = 0; i < 2; ++i) {
    int cur = !(i % 2);
    int cnt = (prv1 != i) + (prv2 != cur);
    ret = add(ret, solve(idx + 1, connected + cnt, i, cur));
  }
  return ret;
}
int main() {
  cout << fixed << setprecision(12), ios::sync_with_stdio(false),
      cin.tie(nullptr), cout.tie(nullptr);
  cin >> n >> k;
  memset(mem, -1, sizeof mem);
  cout << add(add(solve(0, 1, 0, 0), solve(0, 1, 1, 1)),
              add(solve(0, 2, 1, 0), solve(0, 2, 0, 1)));
  return 0;
}

### Prompt

Please provide a cpp coded solution to the problem described below:

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;
double const EPS = 1e-12, PI = acos(-1);
const int N = 2e3 + 9, M = 1e6 + 9, OO = 1e9 + 7, MOD = 1e9 + 7,
          MOD2 = 998244353;
const long long INF = 2e18;
int mem[N][N][3][3], n, k;
int add(long long x, int y) {
  x += y;
  while (x >= MOD2) x -= MOD2;
  while (x < 0) x += MOD2;
  return x;
}
int solve(int idx, int connected, int prv1, int prv2) {
  if (idx + 1 == n) return connected == k;
  if (connected > k) return 0;
  int& ret = mem[idx][connected][prv1][prv2];
  if (~ret) return ret;
  ret = 0;
  for (int i = 0; i < 2; ++i) {
    bool can = (prv1 != i) && (prv2 != i);
    ret = add(ret, solve(idx + 1, connected + can, i, i));
  }
  for (int i = 0; i < 2; ++i) {
    int cur = !(i % 2);
    int cnt = (prv1 != i) + (prv2 != cur);
    ret = add(ret, solve(idx + 1, connected + cnt, i, cur));
  }
  return ret;
}
int main() {
  cout << fixed << setprecision(12), ios::sync_with_stdio(false),
      cin.tie(nullptr), cout.tie(nullptr);
  cin >> n >> k;
  memset(mem, -1, sizeof mem);
  cout << add(add(solve(0, 1, 0, 0), solve(0, 1, 1, 1)),
              add(solve(0, 2, 1, 0), solve(0, 2, 0, 1)));
  return 0;
}

```