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 NMouad21
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FReader in = new FReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        DBicolorings solver = new DBicolorings();
        solver.solve(1, in, out);
        out.close();
    }

    static class DBicolorings {
        private int n;
        private int k;
        private int[][][] dp;
        private static final int M = 998244353;

        public void solve(int testNumber, FReader in, PrintWriter out) {
            n = in.nextInt();
            k = in.nextInt();

            dp = new int[4][n][k + 1];
            for (int[][] sub : dp)
                for (int[] subsub : sub)
                    Arrays.fill(subsub, -1);

            int ans = 0;
            for (int i = 0; i < 4; ++i) {
                ans += solve(1, (i == 0 || i == 3) ? 1 : 2, i);
                ans %= M;
            }

            out.println(ans);
        }

        private int solve(int i, int taken, int last) {
            if (taken > k) return 0;
            if (i == n) return (k == taken ? 1 : 0);
            if (dp[last][i][taken] != -1) return dp[last][i][taken];

            int ans = 0;
            for (int j = 0; j < 4; ++j) {
                if (j == 0 || j == 3) {
                    if ((last & 1) == (j & 1) || (j >> 1) == (last >> 1)) {
                        ans += solve(i + 1, taken, j);
                    } else {
                        ans += solve(i + 1, taken + 1, j);
                    }
                } else {
                    if ((last & 1) != (j & 1) && (j >> 1) != (last >> 1)) {
                        ans += solve(i + 1, taken + 2, j);
                    } else if ((last & 1) != (j & 1) || (j >> 1) != (last >> 1)) {
                        ans += solve(i + 1, taken + 1, j);
                    } else {
                        ans += solve(i + 1, taken, j);
                    }
                }
                ans %= M;
            }

            return dp[last][i][taken] = ans;
        }

    }

    static class FReader {
        private BufferedReader r;
        private String line;
        private StringTokenizer st;
        private String token;

        public FReader() {
            this(System.in);
        }

        public FReader(InputStream i) {
            r = new BufferedReader(new InputStreamReader(i));
        }

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

        private String peekToken() {
            if (token == null)
                try {
                    while (st == null || !st.hasMoreTokens()) {
                        line = r.readLine();
                        if (line == null) return null;
                        st = new StringTokenizer(line);
                    }
                    token = st.nextToken();
                } catch (IOException e) {
                }
            return token;
        }

        private String nextToken() {
            String ans = peekToken();
            token = null;
            return ans;
        }

    }
}

