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>


/*
 * Created by cravuri on 9/20/18
 */

//import java.util.Scanner;
//
//public class Bicolorings {
//
//   public static void main(String[] args) {
//      Scanner sc = new Scanner(System.in);
//      int n = sc.nextInt();
//      int k = sc.nextInt();
//      int[][][] dp = new int[n + 1][2005][4]; // ww wb bw bb
//      int[][] oldDp = new int[2005][4];
//      int[][] newDp = new int[2005][4];
//      oldDp[2][0] = 1;
//      oldDp[3][1] = 1;
//      oldDp[3][2] = 1;
//      oldDp[2][3] = 1;
//
//      dp[1][2][0] = 1;
//      dp[1][3][1] = 1;
//      dp[1][3][2] = 1;
//      dp[1][2][3] = 1;
//      for (int i = 2; i <= n; i++) {
//         for (int j = 2; j <= k + 1; j++) {
//            newDp[j][0] = oldDp[j][0] + oldDp[j][1] + oldDp[j][2] + oldDp[j - 1][3];
//            newDp[j][1] = oldDp[j - 1][0] + oldDp[j][1] + oldDp[j - 2][2] + oldDp[j - 1][3];
//            newDp[j][2] = oldDp[j - 1][0] + oldDp[j - 2][1] + oldDp[j][2] + oldDp[j - 1][3];
//            newDp[j][3] = oldDp[j - 1][0] + oldDp[j][1] + oldDp[j][2] + oldDp[j][3];
//
//            dp[i][j][0] = dp[i - 1][j][0] + dp[i - 1][j][1] + dp[i - 1][j][2] + dp[i - 1][j - 1][3];
//            dp[i][j][1] = dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j - 2][2] + dp[i - 1][j - 1][3];
//            dp[i][j][2] = dp[i - 1][j - 1][0] + dp[i - 1][j - 2][1] + dp[i - 1][j][2] + dp[i - 1][j - 1][3];
//            dp[i][j][3] = dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j][2] + dp[i - 1][j][3];
//         }
//         for (int j = 0; j <= k + 1; j++) {
//            for (int t = 0; t < 4; t++) {
//               oldDp[j][t] = newDp[j][t];
//               newDp[j][t] = 0;
//            }
//         }
//      }
//      System.out.println(dp[n][k + 1][0]+dp[n][k + 1][1]+dp[n][k + 1][2]+dp[n][k + 1][3]);
//   }
//
//}


/*
 * Created by cravuri on 9/20/18
 */

import java.util.Scanner;

public class Bicolorings {

   static final long MOD = 998244353;

   public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      int n = sc.nextInt();
      int k = sc.nextInt();
//      int[][][] dp = new int[n + 1][2005][4]; // ww wb bw bb
      long[][] oldDp = new long[2005][4];
      long[][] newDp = new long[2005][4];
      oldDp[2][0] = 1;
      oldDp[3][1] = 1;
      oldDp[3][2] = 1;
      oldDp[2][3] = 1;

//      dp[1][2][0] = 1;
//      dp[1][3][1] = 1;
//      dp[1][3][2] = 1;
//      dp[1][2][3] = 1;
      for (int i = 2; i <= n; i++) {
         for (int j = 2; j <= k + 1; j++) {
            newDp[j][0] = oldDp[j][0] + oldDp[j][1] + oldDp[j][2] + oldDp[j - 1][3];
            newDp[j][1] = oldDp[j - 1][0] + oldDp[j][1] + oldDp[j - 2][2] + oldDp[j - 1][3];
            newDp[j][2] = oldDp[j - 1][0] + oldDp[j - 2][1] + oldDp[j][2] + oldDp[j - 1][3];
            newDp[j][3] = oldDp[j - 1][0] + oldDp[j][1] + oldDp[j][2] + oldDp[j][3];

//            dp[i][j][0] = dp[i - 1][j][0] + dp[i - 1][j][1] + dp[i - 1][j][2] + dp[i - 1][j - 1][3];
//            dp[i][j][1] = dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j - 2][2] + dp[i - 1][j - 1][3];
//            dp[i][j][2] = dp[i - 1][j - 1][0] + dp[i - 1][j - 2][1] + dp[i - 1][j][2] + dp[i - 1][j - 1][3];
//            dp[i][j][3] = dp[i - 1][j - 1][0] + dp[i - 1][j][1] + dp[i - 1][j][2] + dp[i - 1][j][3];
         }
         for (int j = 0; j <= k + 1; j++) {
            for (int t = 0; t < 4; t++) {
               oldDp[j][t] = newDp[j][t] % MOD;
               newDp[j][t] = 0;
            }
         }
      }
      System.out.println((oldDp[k + 1][0]+oldDp[k + 1][1]+oldDp[k + 1][2]+oldDp[k + 1][3]) % MOD);
   }

}
