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>
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.List;
import java.util.StringTokenizer;
import java.util.TreeMap;

public class Program {

  public void solve() {

    int n = nextInt();
    int k = nextInt();
    int mod = 998_244_353;

    // n - кол-во столбцов, k - кол-во компонент
    int[][][] dp = new int[n + 1][k + 10][4];
    // 0 - 00, 1 - 01, 2 - 10, 3 - 11

    dp[1][1][0] = 1;
    dp[1][1][3] = 1;

    dp[1][2][1] = 1;
    dp[1][2][2] = 1;

    int[][] next = new int[][]{
        {0, 1, 1, 1},
        {0, 0, 2, 0},
        {0, 2, 0, 0},
        {1, 1, 1, 0}
    };

    for (int i = 1; i < n; i++) {
      for (int j = 1; j < k + 1; j++) {
        for (int l = 0; l < 4; l++) {
          for (int m = 0; m < 4; m++) {
            dp[i + 1][j + next[l][m]][m] += dp[i][j][l];
            dp[i + 1][j + next[l][m]][m] %= mod;
          }
        }
      }
    }

    long ans = 0;
    for (int i = 0; i < 4; i++) {
      ans += dp[n][k][i];
    }
    ans %= mod;
    out.println(ans);

  }

  public static void main(String[] args) {
    new Program().run();
  }

  public void run() {
    try {
      init();
      solve();
      out.close();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  public void init() {
    in = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(System.out);
  }

  BufferedReader in;
  PrintWriter out;
  StringTokenizer tok = new StringTokenizer("");

  String nextString() {
    while (!tok.hasMoreTokens()) {
      try {
        tok = new StringTokenizer(in.readLine());
      } catch (Exception e) {
        return null;
      }
    }
    return tok.nextToken();
  }

  int nextInt() {
    return Integer.parseInt(nextString());
  }

  long nextLong() {
    return Long.parseLong(nextString());
  }
}
