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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Vadim Semenov
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static final class TaskD {
        private static final int MODULO = 998244353;

        public void solve(int __, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int k = in.nextInt();
            int[][] distance = new int[4][4];
            for (int oldMask = 0; oldMask < 4; ++oldMask) {
                for (int newMask = 0; newMask < 4; ++newMask) {
                    distance[oldMask][newMask] = distance(oldMask, newMask);
                }
            }
            int[][][] dp = new int[2][4][k + 1];
            boolean[][][] possible = new boolean[2][4][k + 1];
            int cur = 0;
            dp[cur][0][1] = dp[cur][3][1] = 1;
            possible[cur][0][1] = possible[cur][3][1] = true;
            if (2 <= k) {
                dp[cur][1][2] = dp[cur][2][2] = 1;
                possible[cur][1][2] = possible[cur][2][2] = true;
            }
            for (int i = 1; i < n; ++i) {
                int next = cur ^ 1;
                for (int[] d : dp[next]) Arrays.fill(d, 0);
                for (boolean[] d : possible[next]) Arrays.fill(d, false);
                for (int oldMask = 0; oldMask < 4; ++oldMask) {
                    for (int count = 0; count <= k; ++count) {
                        if (possible[cur][oldMask][count]) {
                            for (int newMask = 0; newMask < 4; ++newMask) {
                                int ad = distance[oldMask][newMask];
                                if (count + ad > k) continue;
                                possible[next][newMask][count + ad] = true;
                                dp[next][newMask][count + ad] = (dp[next][newMask][count + ad] + dp[cur][oldMask][count]) % MODULO;
                            }
                        }
                    }
                }
                cur = next;
            }
            long answer = 0;
            for (int mask = 0; mask < 4; ++mask) {
                if (possible[cur][mask][k]) {
                    answer += dp[cur][mask][k];
                }
            }
            out.println(answer % MODULO);
        }

        private int distance(int oldMask, int newMask) {
            boolean oldSame = same(oldMask);
            boolean newSame = same(newMask);
            if (oldMask == newMask) {
                return 0;
            } else if (oldSame && !newSame) {
                return 1;
            } else if (!oldSame && newSame) {
                return 0;
            } else if (oldSame && newSame) {
                return 1;
            } else if (!oldSame && !newSame) {
                return 2;
            } else throw new IllegalStateException("POLUNDRA");
        }

        private boolean same(int oldMask) {
            return oldMask == 0 || oldMask == 3;
        }

    }

    static class InputReader {
        private final BufferedReader reader;
        private StringTokenizer tokenizer;

        public InputReader(InputStream in) {
            reader = new BufferedReader(new InputStreamReader(in));
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(readLine());
            }
            return tokenizer.nextToken();
        }

        public String readLine() {
            String line;
            try {
                line = reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            return line;
        }

    }
}

