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 TaskD
{
	public static void main(String[] args)
	{
		new TaskD(System.in, System.out);
	}

	static class Solver implements Runnable
	{
		static final long MOD = 998244353;
		int n, k;
		long[][][] dp;
		InputReader in;
		PrintWriter out;

		void solve2() throws IOException
		{
			int tests = 100;

			while (tests-- > 0)
			{
				int n = (int) (Math.random() * 20) + 1;
				int k = (int) (Math.random() * (2 * n)) + 1;
				System.out.println("tests : " + tests);

//				solve2(n, k);
			}
		}

//		void solve2(int n, int k) throws IOException
		void solve() throws IOException
		{
			n = in.nextInt();
			k = in.nextInt();
			dp = new long[n][k + 1][4];

/*			if (k == 1)
			{
				out.println(2);

				return;
			}*/

			for (int i = 0; i < n; i++)
				for (int j = 0; j <= k; j++)
					Arrays.fill(dp[i][j], -1);

			for (int i = 0; i < 4; i++)
				dp[0][0][i] = 0;

			if (k >= 1)
				dp[0][1][0] = dp[0][1][3] = 1;

			if (k >= 2)
				dp[0][2][1] = dp[0][2][2] = 1;

			long ans = 0;

			for (int i = 0; i < 4; i++)
				ans = CMath.mod(ans + find(n - 1, k, i), MOD);

			long bruteAnswer = bruteSolver(n, k);

			out.println(ans);
//			System.out.println("Brute Answer : " + bruteAnswer);
//			System.out.println("My Answer : " + (ans / 2));

			if (bruteAnswer != ans)
			{
				System.out.println("Caught!!");
				System.out.println("n : " + n + ", k : " + k + ", ans : " + ans + ", bruteAns : " + bruteAnswer);
				System.exit(0);
			}
		}

		long find(int ind, int comp, int mask)
		{
			if (ind == -1 || comp <= 0)
				return 0;

			if (dp[ind][comp][mask] != -1)
				return dp[ind][comp][mask];

			long cnt;

			// same no. of components at ind - 1
			if (mask == 0)
//				cnt = CMath.mod(find(ind - 1, comp, 0) + find(ind - 1, comp, 1) + find(ind - 1, comp, 2), MOD);
				cnt = CMath.mod(MOD, find(ind - 1, comp, 0), find(ind - 1, comp, 1), find(ind - 1, comp, 2));
			else if (mask == 1)
				cnt = CMath.mod(find(ind - 1, comp, 1), MOD);
			else if (mask == 2)
				cnt = CMath.mod(find(ind - 1, comp, 2), MOD);
			else
				cnt = CMath.mod(MOD, find(ind - 1, comp, 1), find(ind - 1, comp, 2), find(ind - 1, comp, 3));
//				cnt = CMath.mod( find(ind - 1, comp, 1) + find(ind - 1, comp, 2) + find(ind - 1, comp, 3),
//						MOD);

			// comp - 1 no. of components at ind - 1
			if (mask == 0)
				cnt = CMath.mod(cnt + find(ind - 1, comp - 1, 3), MOD);
			else if (mask == 1)
//				cnt = CMath.mod(cnt + find(ind - 1, comp - 1, 0) + find(ind - 1, comp - 1, 3), MOD);
				cnt = CMath.mod(MOD, cnt, find(ind - 1, comp - 1, 0), find(ind - 1, comp - 1, 3));
			else if (mask == 2)
//				cnt = CMath.mod(cnt + find(ind - 1, comp - 1, 0) + find(ind - 1, comp - 1, 3), MOD);
				cnt = CMath.mod(MOD, cnt, find(ind - 1, comp - 1, 0), find(ind - 1, comp - 1, 3));
			else if (mask == 3)
				cnt = CMath.mod(cnt + find(ind - 1, comp - 1, 0), MOD);

			// comp - 2 no. of components at ind - 1
			if (mask == 1)
				cnt = CMath.mod(cnt + find(ind - 1, comp - 2, 2), MOD);
			else if (mask == 2)
				cnt = CMath.mod(cnt + find(ind - 1, comp - 2, 1), MOD);

			return dp[ind][comp][mask] = cnt;
		}

		long bruteSolver(int n, int k)
		{
			int mod = 998244353;
			int[][] as = new int[n + 1][2 * n + 2];
			int[][] ad = new int[n + 1][2 * n + 2];

			as[1][1] = 2;
			ad[1][2] = 2;

			for (int i = 1; i < n; ++i)
			{
				for (int j = 1; j < 2 * n; ++j)
				{
					as[i + 1][j] = (as[i + 1][j] + as[i][j]) % mod;
					as[i + 1][j + 1] = (as[i + 1][j + 1] + as[i][j]) % mod;
					ad[i + 1][j + 1] = (ad[i + 1][j + 1] + as[i][j]) % mod;
					ad[i + 1][j + 1] = (ad[i + 1][j + 1] + as[i][j]) % mod;
					as[i + 1][j] = (as[i + 1][j] + ad[i][j]) % mod;
					as[i + 1][j] = (as[i + 1][j] + ad[i][j]) % mod;
					ad[i + 1][j] = (ad[i + 1][j] + ad[i][j]) % mod;
					ad[i + 1][j + 2] = (ad[i + 1][j + 2] + ad[i][j]) % mod;
				}
			}

			return (as[n][k] + ad[n][k]) % mod;
		}

		public Solver(InputReader in, PrintWriter out)
		{
			this.in = in;
			this.out = out;
		}

		@Override public void run()
		{
			try
			{
				solve();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
		}

	}

	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public int read()
		{
			if (numChars == -1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}

			return buf[curChar++];
		}

		public int nextInt()
		{
			int c = read();

			while (isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();

				res *= 10;
				res += c & 15;

				c = read();
			} while (!isSpaceChar(c));

			return res * sgn;
		}

		public boolean isSpaceChar(int c)
		{
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public void close()
		{
			try
			{
				stream.close();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
		}

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

	}

	static class CMath
	{
		static long mod(long number, long mod)
		{
			return number - (number / mod) * mod;
		}

		static long mod(long mod, long... numbers)
		{
			long modSum = numbers[0];

			for (int i = 1; i < numbers.length; i++)
				modSum = mod(modSum + numbers[i], mod);

			return modSum;
		}

	}

	public TaskD(InputStream inputStream, OutputStream outputStream)
	{
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		Thread thread = new Thread(null, new Solver(in, out), "TaskD", 1 << 29);

		try
		{
			thread.start();
			thread.join();
		}
		catch (InterruptedException e)
		{
			e.printStackTrace();
		}
		finally
		{
			in.close();
			out.flush();
			out.close();
		}
	}

}
