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 \le n \le 1000$, $1 \le k \le 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]

Difficulty: MEDIUM_HARD

Solutions:
(n, k) = list(map(int, input().split()))
same = [0] * (k + 1)
diff = [0] * (k + 1)
mod = 998244353
same[1] = 2
if k > 1:
	diff[2] = 2
for i in range(n - 1):
	newsame = [0] * (k + 1)
	newdiff = [0] * (k + 1)
	for i in range(1, k + 1):
		newsame[i] = (same[i] + same[i - 1] + 2 * diff[i]) % mod
	for i in range(2, k + 1):
		newdiff[i] = (2 * same[i - 1] + diff[i] + diff[i - 2]) % mod
	same = newsame
	diff = newdiff
print((same[-1] + diff[-1]) % mod)


import itertools
(n, k) = [int(i) for i in input().split()]
kas = [[0, 0, 0, 0], [1, 0, 0, 1], [0, 1, 1, 0]]
mmm = 998244353

def count_k(ka, k, t):
	if t == 0:
		return ka[k][0] + ka[k][1] + ka[k][2] + ka[k - 1][3]
	if t == 1:
		return ka[k - 1][0] + ka[k][1] + ka[k - 2][2] + ka[k - 1][3]
	if t == 2:
		return ka[k - 1][0] + ka[k - 2][1] + ka[k][2] + ka[k - 1][3]
	if t == 3:
		return ka[k - 1][0] + ka[k][1] + ka[k][2] + ka[k][3]
for i in range(1, n):
	if len(kas) < k + 1:
		kas.append([0, 0, 0, 0])
		kas.append([0, 0, 0, 0])
	for kk in range(min(len(kas) - 1, k), 1, -1):
		kas[kk] = [count_k(kas, kk, t) % mmm for t in range(4)]
print(sum(kas[k]) % mmm if k < len(kas) else 0)


(n, k) = map(int, input().split())
mod = 998244353
NEXT = {(0, 1): 2, (1, 2): 2}
for i in range(1, n):
	NOW = NEXT
	NEXT = dict()
	for key in NOW:
		if key[0] == 0:
			if k - (n - i) * 2 <= key[1] <= k:
				NEXT[key] = NEXT.get(key, 0) + NOW[key]
			if k - (n - i) * 2 < key[1] + 1 <= k:
				NEXT[0, key[1] + 1] = NEXT.get((0, key[1] + 1), 0) + NOW[key]
				NEXT[1, key[1] + 1] = NEXT.get((1, key[1] + 1), 0) + NOW[key] * 2 % mod
		else:
			if k - (n - i) * 2 <= key[1] <= k:
				NEXT[key] = NEXT.get(key, 0) + NOW[key]
				NEXT[0, key[1]] = NEXT.get((0, key[1]), 0) + NOW[key] * 2 % mod
			if k - (n - i) * 2 < key[1] + 2 <= k:
				NEXT[1, key[1] + 2] = NEXT.get((1, key[1] + 2), 0) + NOW[key]
ANS = 0
for key in NEXT:
	if key[1] == k:
		ANS = (ANS + NEXT[key]) % mod
print(ANS)


(n, k) = list(map(int, input().split()))
limit = 998244353
if k > 2 * n:
	print(0)
elif k == 1 or k == 2 * n:
	print(2)
else:
	same = [0] * (k + 1)
	same[1] = 2
	diff = [0] * (k + 1)
	diff[2] = 2
	for i in range(2, n + 1):
		for j in range(min(k, 2 * i), 1, -1):
			same[j] = same[j] + 2 * diff[j] + same[j - 1]
			same[j] %= limit
			diff[j] = diff[j] + 2 * same[j - 1] + diff[j - 2]
			diff[j] %= limit
	print((same[k] + diff[k]) % limit)


pri = 998244353
dp = [[[0 for i in range(2001)] for i in range(1001)] for i in range(2)]
(n, k) = map(int, input().split())
for i in range(1, n + 1):
	if i == 1:
		dp[0][i][1] = 2
		dp[1][i][2] = 2
		continue
	for j in range(1, 2 * i + 1):
		dp[0][i][j] = dp[0][i - 1][j] + dp[0][i - 1][j - 1] + 2 * dp[1][i - 1][j]
		dp[0][i][j] %= pri
		dp[1][i][j] = 2 * dp[0][i - 1][j - 1] + dp[1][i - 1][j] + dp[1][i - 1][j - 2]
		dp[0][i][j] %= pri
		dp[1][i][j] %= pri
y = dp[0][n][k] + dp[1][n][k]
y %= pri
print(y)


def main():
	(n, k) = map(int, input().split(' '))
	if k > 2 * n:
		return 0
	if k == 2 * n or k == 1:
		return 2
	iguales = [0] * (k + 1)
	diferentes = [0] * (k + 1)
	iguales[1] = 2
	diferentes[2] = 2
	modulo = 998244353
	for i in range(1, n):
		(auxigual, auxdiff) = ([0] * (k + 1), [0] * (k + 1))
		for j in range(k):
			auxigual[j + 1] = (iguales[j + 1] + iguales[j] + 2 * diferentes[j + 1]) % modulo
			if j >= 1:
				auxdiff[j + 1] = (diferentes[j + 1] + diferentes[j - 1] + 2 * iguales[j]) % modulo
		iguales = auxigual
		diferentes = auxdiff
	return (iguales[-1] + diferentes[-1]) % modulo
print(main())