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: interview

Starter code:

Solutions:
n,k=list(map(int,input().split()))
mod=998244353

NEXT={(0,1):2,(1,2):2}#ww or wh,point k,場合の数

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]
        #print(NOW,NEXT)




ANS=0
for key in NEXT:
    if key[1]==k:
        ANS=(ANS+NEXT[key])%mod

print(ANS)


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:#00
        return ka[k][0] + ka[k][1] + ka[k][2] + ka[k-1][3]
    if t == 1:#10
        return ka[k-1][0] + ka[k][1] + ka[k-2][2] + ka[k-1][3]
    if t == 2:#01
        return ka[k-1][0] + ka[k-2][1] + ka[k][2] + ka[k-1][3]
    if t == 3:#11
        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())
same=[0]*(k+1)
diff=[0]*(k+1)
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])%998244353
    for i in range(2,k+1):
        newdiff[i]=(2*same[i-1]+diff[i]+diff[i-2])%998244353
    same=newsame
    diff=newdiff
print((same[-1]+diff[-1])%998244353)

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)


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)

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)

n,k = list(map(int,input().split()))

# modulo divisor
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)

mod = 998244353
n,k = list(map(int,input().split()))
dp = [[[0,0] for i in range(2*n+1)] for j in range(n)]
dp[0][1][0] = 2
dp[0][2][1] = 2
for i in range(1,n):
	dp[i][1][0] = 2
for i in range(1,n):
	for j in range(2,k+1):
		dp[i][j][0] = (dp[i-1][j][0] + dp[i-1][j-1][0] + dp[i-1][j][1]*2) % mod
		dp[i][j][1] = (dp[i-1][j][1]+ dp[i-1][j-2][1] + dp[i-1][j-1][0]*2) % mod
# for i in dp:
# 	print (*i)
print ((sum(dp[-1][k])%mod))

# mod = 10**9+7
# n,k = map(int,input().split())
# dp = [[[0,0,0,0] for i in range(2*n+1)] for j in range(n)]
# dp[0][1][0] = 1
# dp[0][1][3] = 1
# dp[0][2][1] = 1
# dp[0][2][2] = 1
# for i in range(1,n):
# 	dp[i][1][0] = 1
# 	dp[i][1][3] = 1
# for i in range(1,n):
# 	for j in range(2,2*(i+1)+1):
# 		dp[i][j][0] = (dp[i-1][j][0] + dp[i-1][j-1][3] + dp[i-1][j][1] + dp[i-1][j][2]) % mod
# 		dp[i][j][1] = (dp[i-1][j][1] + dp[i-1][j-2][2] + dp[i-1][j-1][0] + dp[i-1][j-1][3]) % mod
# 		dp[i][j][2] = (dp[i-1][j-1][0] + dp[i-1][j-1][3] + dp[i-1][j][2] + dp[i-1][j-2][1]) % mod
# 		dp[i][j][3] = (dp[i-1][j][3] + dp[i-1][j-1][0] + dp[i-1][j][1] + dp[i-1][j][2]) % mod
# # for i in dp:
# # 	print (*i)
# print (sum(dp[-1][k])%mod)


#0 denotes white white
#1 denotes white black
#2 denotes black white
#3 denotes black black

pri=998244353
dp=[[[0 for i in range(2001)] for i in range(1001)] for i in range(2)]
n,k=list(map(int,input().split()))
#dp[i][j][k] i denotes type  j denotes index k denotes bycoloring
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)