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.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

import static java.util.Arrays.fill;

/**
 * Created by timur on 28.03.15.
 */

public class TaskD {
    boolean eof;
    BufferedReader br;
    StringTokenizer st;
    PrintWriter out;

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

    public String nextToken() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                eof = true;
                return "-1";
            }
        }
        return st.nextToken();
    }

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

    public long nextLong() {
        return Long.parseLong(nextToken());
    }

    double nextDouble() {
        return Double.parseDouble(nextToken());
    }

    String nextLine() throws IOException {
        return br.readLine();
    }


    void run() throws IOException {
        InputStream input = System.in;
        PrintStream output = System.out;
        try {
            File f = new File("a.in");
            if (f.exists() && f.canRead()) {
                input = new FileInputStream(f);
                output = new PrintStream("a.out");
            }
        } catch (Throwable e) {
        }
        br = new BufferedReader(new InputStreamReader(input));
        out = new PrintWriter(output);
        solve();
        br.close();
        out.close();
    }

    class Pair implements Comparable<Pair> {
        int ind;
        long val;

        public Pair(int ind, long val) {
            this.ind = ind;
            this.val = val;
        }

        @Override
        public boolean equals(Object obj) {
            if (!(obj instanceof Pair)) {
                return false;
            } else {
                return ((Pair) obj).ind == ind;
            }
        }

        @Override
        public int compareTo(Pair o) {
            int x = Long.compare(val, o.val);
            if (x != 0)
                return x;
            else
                return ind - o.ind;
        }
    }

    void solve() {
        int mod = 998244353;

        int n = nextInt(), k = nextInt();
        int[][] cur = new int[k + 4][4], prev;
        cur[0][0] = 1;
        cur[0][3] = 1;
        cur[1][1] = 1;
        cur[1][2] = 1;
//        for (int i = 0; i < k; i++) {
//            out.println();
//            for (int j = 0; j < 4; j++) {
//                out.print(cur[i][j] + " ");
//            }
//        }
//        out.println();
        for (int i = 1; i < n; i++) {
            prev = new int[k + 4][4];
            for (int j = 0; j < k; j++) {
                for (int l = 0; l < 4; l++) {
                    prev[j][l] = cur[j][l];
                }
            }
            for (int j = 0; j < k; j++) {
                for (int tprev = 0; tprev < 4; tprev += 3) {
                    for (int tcur = 0; tcur < 4; tcur++) {
                        if (tcur != tprev) {
                            cur[j + 1][tcur] = (cur[j + 1][tcur] + prev[j][tprev]) % mod;
                        }
                    }
                }
                for (int tprev = 1; tprev < 3; tprev++) {
                    for (int tcur = 0; tcur < 4; tcur++) {
                        if (tcur != tprev) {
                            if (tcur == 3 - tprev) {
                                cur[j + 2][tcur] = (cur[j + 2][tcur] + prev[j][tprev]) % mod;
                            } else {
                                cur[j][tcur] = (cur[j][tcur] + prev[j][tprev]) % mod;
                            }
                        }
                    }
                }
            }
//
//            for (int t = 0; t < k; t++) {
//                out.println();
//                for (int j = 0; j < 4; j++) {
//                    out.print(cur[t][j] + " ");
//                }
//            }
//            out.println();
        }



        int ans = 0;
        for (int i = 0; i < 4; i++) {
            ans = (ans + cur[k - 1][i]) % mod;
        }
        out.print(ans);
    }

}