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.*;
import java.util.*;

public class P1051D {
	static final long LARGE_LONG = 1000000000000000000L;
	static final int LARGE_INT = 1000000007;
	static final int ANOTHER_INT = 998244353;
	
	public static void main(String[] args) throws IOException {
		FastReader in = new FastReader();
		PrintWriter out = new PrintWriter(System.out);
		
		int N = in.nextInt();
		int K = in.nextInt();
		long[][][] dp = new long[N+1][4][K+2];	// dp[i][p][j] = number of ways to have j components, 00 ww, 01 wb, 
		dp[1][0][1] = 1;	// ww, 1 component
		dp[1][1][2] = 1;	// wb, 2 components
		dp[1][2][2] = 1;	// bw, 2 components
		dp[1][3][1] = 1;	// bb, 1 component
		
		for (int i = 2; i <= N; i++) {
			dp[i][0][1] = dp[i-1][0][1] + dp[i-1][1][1] + dp[i-1][2][1] + dp[i-1][3][0];
			dp[i][1][1] = dp[i-1][0][0] + dp[i-1][1][1] + dp[i-1][3][0];
			dp[i][2][1] = dp[i-1][0][0] + dp[i-1][2][1] + dp[i-1][3][0];
			dp[i][3][1] = dp[i-1][0][0] + dp[i-1][1][1] + dp[i-1][2][1] + dp[i-1][3][1];
			for (int j = 2; j <= K; j++) {
				dp[i][0][j] = dp[i-1][0][j] + dp[i-1][1][j] + dp[i-1][2][j] + dp[i-1][3][j-1];
				dp[i][1][j] = dp[i-1][0][j-1] + dp[i-1][1][j] + dp[i-1][2][j-2] + dp[i-1][3][j-1];
				dp[i][2][j] = dp[i-1][0][j-1] + dp[i-1][1][j-2] + dp[i-1][2][j] + dp[i-1][3][j-1];
				dp[i][3][j] = dp[i-1][0][j-1] + dp[i-1][1][j] + dp[i-1][2][j] + dp[i-1][3][j];
			}
			for (int p = 0; p<4; p++) for (int j = 1; j <= K; j++) { 
				dp[i][p][j] %=  ANOTHER_INT;
			}
		}
		out.println((dp[N][0][K] + dp[N][1][K] + dp[N][2][K] + dp[N][3][K]) % ANOTHER_INT);
		out.close();
	}
	
	/* FastReader code from  https://www.geeksforgeeks.org/fast-io-in-java-in-competitive-programming/ 
	   nextLine modified, and added next(), and hasNext()
	*/
	static class FastReader { 
        final private int BUFFER_SIZE = 1 << 16; 
        final private int MAX_LINE_SIZE = 1 << 20; 
        private DataInputStream din; 
        private byte[] buffer, lineBuf; 
        private int bufferPointer, bytesRead; 
  
        public FastReader() { 
            din = new DataInputStream(System.in); 
            buffer = new byte[BUFFER_SIZE]; 
            bufferPointer = bytesRead = 0; 
        } 
        public FastReader(String file_name) throws IOException { 
            din = new DataInputStream(new FileInputStream(file_name)); 
            buffer = new byte[BUFFER_SIZE]; 
            bufferPointer = bytesRead = 0; 
        } 
		public boolean hasNext() throws IOException { 
            byte c; 
            while ((c = read()) != -1) { 
				if (c > ' ') {
					bufferPointer--;
					return true;
				}
			}
			return false;
		}
        public String nextLine() throws IOException { 
			if (lineBuf == null)	lineBuf = new byte[MAX_LINE_SIZE];
			int ctr = 0;
            byte c; 
            while ((c = read()) != -1) { 
                if (c == '\r')        continue; 
                if (c == '\n')        break; 
                lineBuf[ctr++] = c; 
            } 
            return new String(lineBuf, 0, ctr); 
        }
		public String next() throws IOException { 
			if (lineBuf == null)	lineBuf = new byte[MAX_LINE_SIZE];
			int ctr = 0;
            byte c = read(); 
            while (c <= ' ')  	c = read(); 
			while (c > ' ') {
				lineBuf[ctr++] = c;
				c = read();
			}
			return new String(lineBuf, 0, ctr);
		}
        public int nextInt() throws IOException { 
            int ret = 0; 
            byte c = read(); 
            while (c <= ' ')   c = read(); 
            boolean neg = (c == '-'); 
            if (neg)           c = read(); 
            do { 
                ret = ret * 10 + c - '0'; 
            } while ((c = read()) >= '0' && c <= '9'); 
  
            if (neg)           return -ret; 
            return ret; 
        } 
        public long nextLong() throws IOException { 
            long ret = 0; 
            byte c = read(); 
            while (c <= ' ')    c = read(); 
            boolean neg = (c == '-'); 
            if (neg)            c = read(); 
            do { 
                ret = ret * 10 + c - '0'; 
            } while ((c = read()) >= '0' && c <= '9'); 
            if (neg)            return -ret; 
            return ret; 
        } 
        public double nextDouble() throws IOException { 
            double ret = 0, div = 1; 
            byte c = read(); 
            while (c <= ' ') 
                c = read(); 
            boolean neg = (c == '-'); 
            if (neg)  	c = read(); 
            do { 
                ret = ret * 10 + c - '0'; 
            } 
            while ((c = read()) >= '0' && c <= '9'); 
            if (c == '.') { 
                while ((c = read()) >= '0' && c <= '9') { 
                    ret += (c - '0') / (div *= 10); 
                } 
            } 
            if (neg)     return -ret; 
            return ret; 
        } 
        private void fillBuffer() throws IOException { 
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE); 
            if (bytesRead == -1) 
                buffer[0] = -1; 
        } 
        private byte read() throws IOException { 
            if (bufferPointer == bytesRead)     fillBuffer(); 
            return buffer[bufferPointer++]; 
        } 
        public void close() throws IOException { 
            if (din == null) 	   return; 
            din.close(); 
        } 
    } 
}

