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>
# SHRi GANESHA    author: Kunal Verma #
import os
import sys
from collections import Counter, deque
from io import BytesIO, IOBase
from math import gcd, inf, sqrt, ceil, radians, cos, sin


def lcm(a, b):

    return (a * b) // gcd(a, b)


'''
    mod = 10 ** 9 + 7
    fac = [1]
    for i in range(1, 2 * 10 ** 5 + 1):
        fac.append((fac[-1] * i) % mod)
    fac_in = [pow(fac[-1], mod - 2, mod)]
    for i in range(2 * 10 ** 5, 0, -1):
        fac_in.append((fac_in[-1] * i) % mod)
    fac_in.reverse()
    def comb(a, b):
        if a < b:
            return 0
        return (fac[a] * fac_in[b] * fac_in[a - b]) % mod
'''
#MAXN = 10000004
# spf = [0 for i in range(MAXN)]
# adj = [[] for i in range(MAXN)]
def sieve():
    global spf, adj, MAXN
    spf[1] = 1
    for i in range(2, MAXN):
        spf[i] = i

    for i in range(2, MAXN):
        if i * i > MAXN:
            break
        if (spf[i] == i):
            for j in range(i * i, MAXN, i):
                if (spf[j] == j):
                    spf[j] = i
def getdistinctFactorization(n):
    global adj, spf, MAXN
    for i in range(1, n + 1):
        index = 1
        x = i
        if (x != 1):
            adj[i].append(spf[x])
        x = x // spf[x]
        while (x != 1):
            if (adj[i][index - 1] != spf[x]):
                adj[i].append(spf[x])
                index += 1
            x = x // spf[x]
def printDivisors(n):
    i = 2
    z = [1, n]
    while i <= sqrt(n):
        if (n % i == 0):
            if (n / i == i):
                z.append(i)
            else:
                z.append(i)
                z.append(n // i)
        i = i + 1
    return z
def create(n, x, f):
    pq = len(bin(n)[2:])
    if f == 0:
        tt = min
    else:
        tt = max
    dp = [[inf] * n for _ in range(pq)]
    dp[0] = x
    for i in range(1, pq):
        for j in range(n - (1 << i) + 1):
            dp[i][j] = tt(dp[i - 1][j], dp[i - 1][j + (1 << (i - 1))])
    return dp
def enquiry(l, r, dp, f):
    if l > r:
        return inf if not f else -inf
    if f == 1:
        tt = max
    else:
        tt = min
    pq1 = len(bin(r - l + 1)[2:]) - 1
    return tt(dp[pq1][l], dp[pq1][r - (1 << pq1) + 1])
def SieveOfEratosthenes(n):
    prime = [True for i in range(n + 1)]
    p = 2
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n + 1, p):
                prime[i] = False
        p += 1
    x = []
    for i in range(2, n + 1):
        if prime[i]:
            x.append(i)
    return x
def func(a,d,i):
    if i==0:
        return [a[0]]
    an=[]
    for j in range(i,0,-1):
        for xx in func(a,d,j-1):
            an.append(d[i][j]^xx)

    an.append(d[i][0])
    return an

def main():
    n, k = map(int, input().split())
    dp = [[[0] * 4 for j in range(k + 4)] for i in range(n)]
    mod = 998244353
    dp[0][1][2] = 1
    dp[0][1][3] = 1
    dp[0][2][1] = 1
    dp[0][2][0] = 1
    for i in range(1, n):

        for j in range(1, k + 1):

            for p in range(4):
                # pass
                dp[i][j][p] = (dp[i - 1][j][p] + dp[i][j][p]) % mod

            dp[i][j][3] = (dp[i][j][3] + dp[i - 1][j][0] ) % mod
            dp[i][j][2] = (dp[i][j][2] +  dp[i - 1][j][1]) % mod
            dp[i][j][3] = (dp[i][j][3] + dp[i - 1][j][0]) % mod
            dp[i][j][2] = (dp[i][j][2]  + dp[i - 1][j][1]) % mod

            if j > 2:
                dp[i][j][0] = (dp[i - 1][j - 2][1] + dp[i][j][0]) % mod

                dp[i][j][1] = (dp[i][j][1] + dp[i - 1][j - 2][0]) % mod
            if j > 1:
                dp[i][j][0] = (dp[i][j][0] + dp[i - 1][j - 1][2] ) % mod
                dp[i][j][0] = (dp[i][j][0] + dp[i - 1][j - 1][3] ) % mod
                
                dp[i][j][1] = (dp[i][j][1] + dp[i - 1][j - 1][2] ) % mod
                dp[i][j][1] = (dp[i][j][1] +  dp[i - 1][j - 1][3]) % mod
                dp[i][j][3] = (dp[i][j][3] + dp[i - 1][j - 1][2]) % mod
                dp[i][j][2] = (dp[i][j][2] + dp[i - 1][j - 1][3]) % mod

    print(sum(dp[n - 1][k]) % mod)
# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")

if __name__ == '__main__':
    main()
