# input
import sys
input = sys.stdin.readline
II = lambda : int(input())
MI = lambda : map(int, input().split())
LI = lambda : [int(a) for a in input().split()]
SI = lambda : input().rstrip()
LLI = lambda n : [[int(a) for a in input().split()] for _ in range(n)]
LSI = lambda n : [input().rstrip() for _ in range(n)]
MI_1 = lambda : map(lambda x:int(x)-1, input().split())
LI_1 = lambda : [int(a)-1 for a in input().split()]

mod = 998244353
inf = 1001001001001001001
ordalp = lambda s : ord(s)-65 if s.isupper() else ord(s)-97
ordallalp = lambda s : ord(s)-39 if s.isupper() else ord(s)-97
yes = lambda : print("Yes")
no = lambda : print("No")
yn = lambda flag : print("Yes" if flag else "No")

prinf = lambda ans : print(ans if ans < 1000001001001001001 else -1)
alplow = "abcdefghijklmnopqrstuvwxyz"
alpup = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
alpall = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
URDL = {'U':(-1,0), 'R':(0,1), 'D':(1,0), 'L':(0,-1)}
DIR_4 = [[-1,0],[0,1],[1,0],[0,-1]]
DIR_8 = [[-1,0],[-1,1],[0,1],[1,1],[1,0],[1,-1],[0,-1],[-1,-1]]
DIR_BISHOP = [[-1,1],[1,1],[1,-1],[-1,-1]]
prime60 = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59]
sys.set_int_max_str_digits(0)
# sys.setrecursionlimit(10**6)
# import pypyjit
# pypyjit.set_param('max_unroll_recursion=-1')

from collections import defaultdict,deque
from heapq import heappop,heappush
from bisect import bisect_left,bisect_right
DD = defaultdict
BSL = bisect_left
BSR = bisect_right

# https://github.com/atcoder/ac-library/blob/master/atcoder/convolution.hpp
from array import array
MOD = 998244353
IMAG = 911660635
IIMAG = 86583718
INV2 = 499122177
rate2 = array('I', [0, 911660635, 509520358, 369330050, 332049552, 983190778, 123842337, 238493703, 975955924, 603855026, 856644456, 131300601, 842657263, 730768835, 942482514, 806263778, 151565301, 510815449, 503497456, 743006876, 741047443, 56250497, 867605899, 0])
irate2 = array('I', [0, 86583718, 372528824, 373294451, 645684063, 112220581, 692852209, 155456985, 797128860, 90816748, 860285882, 927414960, 354738543, 109331171, 293255632, 535113200, 308540755, 121186627, 608385704, 438932459, 359477183, 824071951, 103369235, 0])
rate3 = array('I', [0, 372528824, 337190230, 454590761, 816400692, 578227951, 180142363, 83780245, 6597683, 70046822, 623238099, 183021267, 402682409, 631680428, 344509872, 689220186, 365017329, 774342554, 729444058, 102986190, 128751033, 395565204, 0])
irate3 = array('I', [0, 509520358, 929031873, 170256584, 839780419, 282974284, 395914482, 444904435, 72135471, 638914820, 66769500, 771127074, 985925487, 262319669, 262341272, 625870173, 768022760, 859816005, 914661783, 430819711, 272774365, 530924681, 0])

# https://judge.yosupo.jp/submission/55648
def butterfly(a: list):
    n = len(a)
    h = (n - 1).bit_length()
    le = 0
    while le < h:
        if h - le == 1:
            p = 1 << (h - le - 1)
            rot = 1
            for s in range(1 << le):
                offset = s << (h - le)
                for i in range(p):
                    l = a[i + offset]
                    r = a[i + offset + p] * rot
                    a[i + offset] = (l + r) % MOD
                    a[i + offset + p] = (l - r) % MOD
                rot *= rate2[(~s & -~s).bit_length()]
                rot %= MOD
            le += 1
        else:
            p = 1 << (h - le - 2)
            rot = 1
            for s in range(1 << le):
                rot2 = rot * rot % MOD
                rot3 = rot2 * rot % MOD
                offset = s << (h - le)
                for i in range(p):
                    a0 = a[i + offset]
                    a1 = a[i + offset + p] * rot
                    a2 = a[i + offset + p * 2] * rot2
                    a3 = a[i + offset + p * 3] * rot3
                    a1na3imag = (a1 - a3) % MOD * IMAG
                    a[i + offset] = (a0 + a2 + a1 + a3) % MOD
                    a[i + offset + p] = (a0 + a2 - a1 - a3) % MOD
                    a[i + offset + p * 2] = (a0 - a2 + a1na3imag) % MOD
                    a[i + offset + p * 3] = (a0 - a2 - a1na3imag) % MOD
                rot *= rate3[(~s & -~s).bit_length()]
                rot %= MOD
            le += 2

def butterfly_inv(a: list):
    n = len(a)
    h = (n - 1).bit_length()
    le = h
    while le:
        if le == 1:
            p = 1 << (h - le)
            irot = 1
            for s in range(1 << (le - 1)):
                offset = s << (h - le + 1)
                for i in range(p):
                    l = a[i + offset]
                    r = a[i + offset + p]
                    a[i + offset] = (l + r) % MOD
                    a[i + offset + p] = (l - r) * irot % MOD
                irot *= irate2[(~s & -~s).bit_length()]
                irot %= MOD
            le -= 1
        else:
            p = 1 << (h - le)
            irot = 1
            for s in range(1 << (le - 2)):
                irot2 = irot * irot % MOD
                irot3 = irot2 * irot % MOD
                offset = s << (h - le + 2)
                for i in range(p):
                    a0 = a[i + offset]
                    a1 = a[i + offset + p]
                    a2 = a[i + offset + p * 2]
                    a3 = a[i + offset + p * 3]
                    a2na3iimag = (a2 - a3) * IIMAG % MOD
                    a[i + offset] = (a0 + a1 + a2 + a3) % MOD
                    a[i + offset + p] = (a0 - a1 + a2na3iimag) * irot % MOD
                    a[i + offset + p * 2] = (a0 + a1 - a2 - a3) * irot2 % MOD
                    a[i + offset + p * 3] = (a0 - a1 - a2na3iimag) * irot3 % MOD
                irot *= irate3[(~s & -~s).bit_length()]
                irot %= MOD
            le -= 2

def intt(a):
    if len(a) <= 1: return
    butterfly_inv(a)
    iv = pow(len(a), MOD - 2, MOD)
    for i, x in enumerate(a): a[i] = x * iv % MOD

def multiply(s: list, t: list):
    n = len(s)
    m = len(t)
    if min(n, m) <= 60:
        a = [0] * (n + m - 1)
        for i in range(n):
            if i&0b111 == 0:        
                for j in range(m):
                    a[i + j] += s[i] * t[j]
                    a[i + j] %= MOD
            else:
                for j in range(m):
                    a[i + j] += s[i] * t[j]
        return [x % MOD for x in a]
    a = s.copy()
    b = t.copy()
    z = 1 << (n + m - 2).bit_length()
    a += [0] * (z - n)
    b += [0] * (z - m)
    butterfly(a)
    butterfly(b)
    for i in range(z):
        a[i] *= b[i]
        a[i] %= MOD
    butterfly_inv(a)
    a = a[:n + m - 1]
    iz = pow(z, MOD - 2, MOD)
    return [v * iz % MOD for v in a]

def pow2(s: list):
    n = len(s)
    l = (n << 1) - 1
    if n <= 60:
        a = [0] * l
        for i, x in enumerate(s):
            for j, y in enumerate(s):
                a[i + j] += x * y
        return [x % MOD for x in a]
    z = 1 << (l - 1).bit_length()
    a = s + [0] * (z - n)
    butterfly(a)
    for i, x in enumerate(a): a[i] = x * x % MOD
    butterfly_inv(a)
    a[l:] = []
    iz = pow(z, MOD - 2, MOD)
    return [x * iz % MOD for x in a]

def shrink(a: list):
    while a and not a[-1]: a.pop()

def fps_add(a: list, b: list):
    if len(a) < len(b):
        res = b.copy()
        for i, x in enumerate(a):
            res[i] += x
    else:
        res = a.copy()
        for i, x in enumerate(b):
            res[i] += x
    return [x-MOD if MOD <= x else x for x in res]

def fps_sub(a: list, b: list):
    if len(a) < len(b):
        res = b.copy()
        for i, x in enumerate(a):
            res[i] -= x
        return [MOD-x if 0 < x else -x for x in res]
    else:
        res = a.copy()
        for i, x in enumerate(b):
            res[i] -= x
        return [x if 0 <= x else x+MOD for x in res]

def fps_neg(a: list):
    return [MOD-x if x else 0 for x in a]

def fps_div(a: list, b: list) -> list:
    if len(a) < len(b): return []
    n = len(a) - len(b) + 1
    cnt = 0
    if len(b) > 64:
        return multiply(a[::-1][:n], fps_inv(b[::-1], n))[:n][::-1]
    f = a.copy()
    g = b.copy()
    while g and not g[-1]:
        g.pop()
        cnt += 1
    coef = pow(g[-1], MOD - 2, MOD)
    g = [x * coef % MOD for x in g]
    deg = len(f) - len(g) + 1
    lg = len(g)
    res = [0] * deg
    for i in reversed(range(deg)):
        res[i] = x = f[i + lg - 1] % MOD
        for j, y in enumerate(g):
            f[i + j] -= x * y
    return [x * coef  % MOD for x in res] + [0] * cnt

def fps_mod(a: list, b: list) -> list:
    res = fps_sub(a, multiply(fps_div(a, b),  b))
    while res and not res[-1]: res.pop()
    return res

def fps_divmod(a: list, b: list):
    q = fps_div(a, b)
    r = fps_sub(a, multiply(q, b))
    while r and not r[-1]: r.pop()
    return q, r

def fps_eval(a: list, x: int) -> int:
    r = 0
    w = 1
    for v in a:
        r += w * v % MOD
        w = w * x % MOD
    return r % MOD

def fps_inv(a: list, deg: int=-1):
    # assert(self[0] != 0)
    if deg == -1: deg = len(a)
    res = [0] * deg
    res[0] = pow(a[0], MOD - 2, MOD)
    d = 1
    iv = INV2
    while d < deg:
        d2 = d << 1
        f = [0] * d2
        fl = min(len(a), d2)
        f[:fl] = a[:fl]
        g = [0] * d2
        g[:d] = res[:d]
        butterfly(g)
        butterfly(f)
        for i in range(d2): f[i] = f[i] * g[i] % MOD
        butterfly_inv(f)
        f[:d] = [0] * d
        for i in range(d, d2): f[i] = f[i] * iv % MOD
        butterfly(f)
        for i in range(d2): f[i] = f[i] * g[i] % MOD
        butterfly_inv(f)
        for i in range(d, min(d2, deg)): res[i] = (MOD-f[i]) * iv % MOD
        d <<= 1
        iv = iv * INV2 % MOD
    return res

def fps_pow(a: list, k: int, deg=-1) -> list:
    n = len(a)
    if deg == -1: deg = n
    if k == 0:
        if not deg: return []
        res = [0] * deg
        res[0] = 1
        return res
    for i, x in enumerate(a):
        if x:
            iz = pow(x, MOD - 2, MOD)
            res = [x * iz % MOD for x in a[i:]]
            res = fps_log(res, deg)
            res = [x * k % MOD for x in res]
            res = fps_exp(res, deg)
            coef = pow(x, k, MOD)
            res = [0] * (i * k) + [x * coef % MOD for x in res]
            if len(res) < deg:
                return res + [0] * (deg - len(res))
            return res[:deg]
        if (i + 1) * k >= deg: break
    return [0] * deg

def fps_exp(a: list, deg: int=-1):
    # assert a[0] == 0
    if deg == -1: deg = len(a)
    inv = [0, 1]
    def inplace_integral(f: list) -> list:
        n = len(f)
        while len(inv) <= n:
            j, k = divmod(MOD, len(inv))
            inv.append((-inv[k] * j) % MOD)
        return [0] + [x * inv[i + 1] % MOD for i, x in enumerate(f)]

    b = [1, (a[1] if 1 < len(a) else 0)]
    c = [1]
    z1 = []
    z2 = [1, 1]
    m = 2
    while m < deg:
        y = b + [0] * m
        butterfly(y)
        z1 = z2
        z = [y[i] * p % MOD for i, p in enumerate(z1)]
        intt(z)
        z[:m >> 1] = [0] * (m >> 1)
        butterfly(z)
        for i, p in enumerate(z1): z[i] = z[i] * (-p) % MOD
        intt(z)
        c[m >> 1:] = z[m >> 1:]
        z2 = c + [0] * m
        butterfly(z2)
        tmp = min(len(a), m)
        x = a[:tmp] + [0] * (m - tmp)
        x = fps_diff(x)
        x.append(0)
        butterfly(x)
        for i, p in enumerate(x): x[i] = y[i] * p % MOD
        intt(x)
        for i, p in enumerate(b):
            if not i: continue
            x[i - 1] -= p * i % MOD
        x += [0] * m
        for i in range(m - 1): x[m + i], x[i] = x[i], 0
        butterfly(x)
        for i, p in enumerate(z2): x[i] = x[i] * p % MOD
        intt(x)
        x.pop()
        x = inplace_integral(x)
        x[:m] = [0] * m
        for i in range(m, min(len(a), m << 1)): x[i] += a[i]
        butterfly(x)
        for i, p in enumerate(y): x[i] = x[i] * p % MOD
        intt(x)
        b[m:] = x[m:]
        m <<= 1
    return b[:deg]

def fps_log(a: list, deg=-1) -> list:
    # assert(a[0] == 1)
    if deg == -1: deg = len(a)
    return fps_integral(multiply(fps_diff(a), fps_inv(a, deg))[:deg - 1])

def fps_integral(a: list):
    n = len(a)
    res = [0] * (n + 1)
    if n: res[1] = 1
    for i in range(2, n + 1):
        j, k = divmod(MOD, i)
        res[i] = (-res[k] * j) % MOD
    for i, x in enumerate(a): res[i + 1] = res[i + 1] * x % MOD
    return res

def fps_diff(a: list):
    return [i * x % MOD for i, x in enumerate(a) if i]

def LinearRecurrence(n: int, p: list, q: list):
    """
    [x^n]P(x)/Q(x)
    """
    # assert len(p) < len(q)
    shrink(q)
    while n:
        q2 = q[:]
        for i in range(1,len(q2),2): q2[i] = (-q2[i])%MOD
        s = multiply(p,q2)
        t = multiply(q,q2)
        p = s[n&1::2]
        q = t[0::2]
        n >>= 1
    return p[0] * pow(q[0], -1, MOD) % MOD

def fps_compsite(f: list, g: list):
    """
    g(f(x)) mod x^(n+1)
    """
    # assert len(f) == len(g)
    def trans_multiply(s, t):
        n = len(s)
        m = len(t)
        l = 1 << (max(n, m) - 1).bit_length()
        a = s + [0] * (l - n)
        b = t + [0] * (l - m)
        a = [a[0]] + [a[l - i] for i in range(1, l)]
        butterfly(a)
        butterfly(b)
        iz = pow(l, MOD-2, MOD)
        for i, x in enumerate(b):
            a[i] = a[i] * x % MOD * iz % MOD
        butterfly_inv(a)
        a = [a[0]] + [a[l - i] for i in range(1, l)]
        return a[:n - m + 1]
    
    n = len(f)
    l = 1 << (n - 1).bit_length()
    a = [MOD - x for x in f] + [0] * (2 * l - n)
    b = g + [0] * (l - n) 
    
    def _inner(q, n, k):
        if n == 1:
            p = [0] * (2 * k)
            p[0::2] = b[::-1]
            return p
        siz = 2 * n * k
        r = [MOD - x if i & 1 else x for i,x in enumerate(q)]
        qq = multiply(q, r)
        qq.append(0)
        for i in range(0, siz, 2):
            qq[siz+i] = (qq[siz+i] + 2 * q[i]) % MOD
        nq = [0] * siz
        for j in range(2 * k):
            for i in range(n >> 1):
                nq[n * j + i] = qq[2 * n * j + 2 * i]
        np = _inner(nq, n >> 1, k << 1)
        
        pq = [0] * (2 * siz)
        for j in range(2 * k):
            for i in range(n >> 1):
                pq[2 * n * j + 2 * i + 1] = np[n * j + i]
        
        p = [pq[siz + i] for i in range(siz)]
        pq.pop()
        x = trans_multiply(pq, r)
        p = [(p[i] + x[i]) % MOD for i in range(siz)]
        return p
    
    p = _inner(a, l, 1)
    p = p[l-1::-1]
    return p[:n]

# https://atcoder.jp/contests/abc345/submissions/61504515
def power_projection(f, wt, m):
    """
    sum_{j = 0}^{j = n - 1}(wt_j * [x^j]f^i) (0 <= i < m)
    """
    
    
    if len(f) == 0:
        return [0 for _ in range(m)]
    
    # f[0] = c のとき f[0] = 0 の問題にする.
    if f[0] != 0:
        c = f[0]
        f[0] = 0
        A = power_projection(f, wt, m)
        f[0] = c
        for p in range(m):
            A[p] = A[p] * finv[p] % MOD
        B = [0 for _ in range(m)]
        Pow = 1
        for q in range(m):
            B[q] = Pow * finv[q] % MOD
            Pow = Pow * c % MOD
        A = multiply(A, B)
        while len(A) > m:
            A.pop()
        for i in range(m):
            A[i] = A[i] * fact[i] % MOD
        return A

    n = 1
    log = 1
    while n < len(f):
        n *= 2
        log += 1
    for i in range(n - len(f)):
        f.append(0), wt.append(0)
    wt = wt[::-1]

    M = 2 * n
    btr = [0] * M
    for i in range(1, M):
        btr[i] = (btr[i >> 1] >> 1) + ((i & 1) << (log - 1))

    # W[i] = w_(4 * N) ^ rev(i) in bit-reverse order.
    t, r = 23, 31
    dw = pow(pow(r, -1, MOD), (1 << t) // (2 * M), MOD)  # 4*N = 2*M
    W = [0] * M
    w = 1
    for i in btr:
        W[i] = w
        w = w * dw % MOD

    root_delta = 7516853
    inv_root_delta = pow(root_delta, -1, M)
    mask = M - 1
    inv_2 = (MOD + 1) // 2
    mul_w = [0] * M
    pair = [0] * M
    for i in range(M):
        rev_ai = (btr[i] * inv_root_delta) & mask
        ai = btr[rev_ai]
        j0 = (i << 1) | (((root_delta * rev_ai) >> log) & 1)
        pair[i] = j0
        mul_w[i] = inv_2 * W[ai] % MOD

    k = 1
    P, Q = [0 for _ in range(2 * n)], [0 for _ in range(2 * n)]
    for i in range(n):
        P[i], Q[i] = wt[i], (-f[i]) % MOD

    # https://noshi91.hatenablog.com/entry/2023/12/10/163348
    while n > 1:
        for i in range(2 * n * k):
            P.append(0), Q.append(0)
        Q[2 * n * k] = 1
        # R(x, y) = Q(-x, y) の fft は Q(x, y)から分かる.
        butterfly(P)
        butterfly(Q)
        # f(x) = e(x^2) + x * o(x^2) のとき fft(e), fft(o) は fft(f) から分かる.
        for i in range(M):
            j = pair[i]
            P[i] = (P[j] * Q[j^1] - P[j^1] * Q[j]) % MOD
            P[i] = P[i] * mul_w[i] % MOD
            Q[i] = Q[j] * Q[j^1] % MOD
        for i in range(2 * n * k):
            P.pop(), Q.pop()
        intt(P)
        intt(Q)
        # x の次数を半分に
        for j in range(2 * k):
            for i in range(n // 2, n):
                P[n * j + i], Q[n * j + i] = 0, 0
        Q[0] = 0
        n, k = n // 2, k * 2
    
    p = [0 for i in range(k)]
    for i in range(k):
        p[i] = P[2 * i]
    p = p[::-1]
    for i in range(m - len(p)):
        p.append(0)
    while len(p) > m:
        p.pop()
    return p


def fps_compsite_inv(f):
    n = len(f) - 1
    # assert f[0] % MOD == 0
    if n == 0: return f    
    # assert f[1] % MOD != 0
    iz = pow(f[1], MOD-2, MOD)
    nf = [x*iz%MOD for x in f]
    wt = [0] * n + [1]
    
    a = power_projection(nf, wt, n + 1)
    # print(a, n)
    g = [0] + fps_pow([n*a[n-i]%MOD*pow(n-i,MOD-2,MOD)%MOD for i in range(n)], MOD-pow(n, MOD-2, MOD))
    p = 1
    for i in range(len(g)):
        g[i] = g[i] * p % MOD
        p = p * iz % MOD
    return g

# ?
# def fps_compsitional_inv(calc, deg):
#     """
#     input
#     calc(g, d) = f(g(x)) mod x^d を計算する
#     fps_compsite よりも良い計算量のものが存在するならば書く
    
#     output
#     g(x) mod x^deg s.t. f(g(x)) = x 
#     """
#     c = deg.bit_length()
#     g = calc([0, 1], 2)
#     g[1] = pow(g[1], -1, MOD)
#     d = 2
#     for i in range(c):
#         d <<= 1
#         fg = calc(g, d)
#         fdg = multiply(fps_diff(fg), fps_inv(fps_diff(g)))
#         fdg[d:] = []
#         fg[1] -= 1
#         g = fps_sub(g, multiply(fg, fps_inv(fdg)))
#         g[d:] = []
#     g[deg:] = []
#     return g


INVMOD = [1,1]
def SubsetSum(d: list) -> list:
    """
    \prod ( 1 + x^i ) ^ d[i]
    
    d[w] = 重さ w が d[w] 種類 1 個ずつある
    r[w] = 重さが w になるような選び方
    """
    n = len(d)
    for i in range(len(INVMOD), n):
        INVMOD.append(-INVMOD[MOD%i] * (MOD//i) % MOD)
    res = [0] * n
    sgn = [-1, 1]
    for i in range(1, n):
        if d[i]:
            tmp = d[i] * i
            for j in range(i, n, i):
                res[j] += tmp * INVMOD[j] * sgn[(j//i)&1] % MOD
    res = fps_exp(res, n)
    return res

def MultisetSum(d: list) -> list:
    """
    \prod ( 1 / ( 1 - x^i ) ) ^ d[i]
    
    d[w] = 重さ w が d[w] 種類 inf 個ずつある
    r[w] = 重さが w になるような選び方
    """
    n = len(d)
    for i in range(len(INVMOD), n):
        INVMOD.append(-INVMOD[MOD%i] * (MOD//i) % MOD)
    res = [0] * n
    for i in range(1, n):
        if d[i]:
            tmp = d[i] * i
            for j in range(i, n, i):
                res[j] += tmp * INVMOD[j] % MOD
    res = fps_exp(res, n)
    return res

fac = [1, 1]
finv = [1, 1]
def tayler_shift(a: list, c: int) -> list:
    global fac, finv
    n = len(a)
    l = len(fac)
    fac += [0] * (n - l)
    finv += [0] * (n - l)
    for i in range(l, n):
        fac[i] = fac[i-1] * i % MOD
    finv[n-1] = pow(fac[n-1], MOD-2, MOD)
    for i in reversed(range(l, n-1)):
        finv[i] = finv[i+1] * (i+1) % MOD
    
    r = [x * fac[i] % MOD for i, x in enumerate(a)]
    b = [0] * n
    b[0] = 1
    for i in range(1, n):
        b[i] = b[i-1] * c % MOD * finv[i] % MOD * fac[i-1] % MOD
    r.reverse()
    res = multiply(r, b)[:n]
    return [x * finv[i] % MOD for i, x in enumerate(reversed(res))]

def fps_product(polys):
    if len(polys) == 0:
        return [1]
    from collections import deque
    que = deque(polys)
    while len(que) > 1:
        que.append(multiply(que.popleft(), que.popleft()))
    return que[0]

def ntt2d(a: list[list]):
    n, m = len(a), len(a[0])
    h = (n - 1).bit_length()
    le = 0
    while le < h:
        if h - le == 1:
            p = 1 << (h - le - 1)
            rot = 1
            for s in range(1 << le):
                offset = s << (h - le)
                for i in range(p):
                    for j in range(m):
                        l = a[i + offset][j]
                        r = a[i + offset + p][j] * rot
                        a[i + offset][j] = (l + r) % MOD
                        a[i + offset + p][j] = (l - r) % MOD
                rot *= rate2[(~s & -~s).bit_length()]
                rot %= MOD
            le += 1
        else:
            p = 1 << (h - le - 2)
            rot = 1
            for s in range(1 << le):
                rot2 = rot * rot % MOD
                rot3 = rot2 * rot % MOD
                offset = s << (h - le)
                for i in range(p):
                    for j in range(m):
                        a0 = a[i + offset][j]
                        a1 = a[i + offset + p][j] * rot
                        a2 = a[i + offset + p * 2][j] * rot2
                        a3 = a[i + offset + p * 3][j] * rot3
                        a1na3imag = (a1 - a3) % MOD * IMAG
                        a[i + offset][j] = (a0 + a2 + a1 + a3) % MOD
                        a[i + offset + p][j] = (a0 + a2 - a1 - a3) % MOD
                        a[i + offset + p * 2][j] = (a0 - a2 + a1na3imag) % MOD
                        a[i + offset + p * 3][j] = (a0 - a2 - a1na3imag) % MOD
                rot *= rate3[(~s & -~s).bit_length()]
                rot %= MOD
            le += 2
    n, m = m, n
    h = (n - 1).bit_length()
    le = 0
    while le < h:
        if h - le == 1:
            p = 1 << (h - le - 1)
            rot = 1
            for s in range(1 << le):
                offset = s << (h - le)
                for i in range(p):
                    for j in range(m):
                        l = a[j][i + offset]
                        r = a[j][i + offset + p] * rot
                        a[j][i + offset] = (l + r) % MOD
                        a[j][i + offset + p] = (l - r) % MOD
                rot *= rate2[(~s & -~s).bit_length()]
                rot %= MOD
            le += 1
        else:
            p = 1 << (h - le - 2)
            rot = 1
            for s in range(1 << le):
                rot2 = rot * rot % MOD
                rot3 = rot2 * rot % MOD
                offset = s << (h - le)
                for i in range(p):
                    for j in range(m):
                        a0 = a[j][i + offset]
                        a1 = a[j][i + offset + p] * rot
                        a2 = a[j][i + offset + p * 2] * rot2
                        a3 = a[j][i + offset + p * 3] * rot3
                        a1na3imag = (a1 - a3) % MOD * IMAG
                        a[j][i + offset] = (a0 + a2 + a1 + a3) % MOD
                        a[j][i + offset + p] = (a0 + a2 - a1 - a3) % MOD
                        a[j][i + offset + p * 2] = (a0 - a2 + a1na3imag) % MOD
                        a[j][i + offset + p * 3] = (a0 - a2 - a1na3imag) % MOD
                rot *= rate3[(~s & -~s).bit_length()]
                rot %= MOD
            le += 2

def intt2d(a : list[list]):
    n, m = len(a), len(a[0])
    h = (n - 1).bit_length()
    le = h
    while le:
        if le == 1:
            p = 1 << (h - le)
            irot = 1
            for s in range(1 << (le - 1)):
                offset = s << (h - le + 1)
                for i in range(p):
                    for j in range(m):
                        l = a[i + offset][j]
                        r = a[i + offset + p][j]
                        a[i + offset][j] = (l + r) % MOD
                        a[i + offset + p][j] = (l - r) * irot % MOD
                irot *= irate2[(~s & -~s).bit_length()]
                irot %= MOD
            le -= 1
        else:
            p = 1 << (h - le)
            irot = 1
            for s in range(1 << (le - 2)):
                irot2 = irot * irot % MOD
                irot3 = irot2 * irot % MOD
                offset = s << (h - le + 2)
                for i in range(p):
                    for j in range(m):
                        a0 = a[i + offset][j]
                        a1 = a[i + offset + p][j]
                        a2 = a[i + offset + p * 2][j]
                        a3 = a[i + offset + p * 3][j]
                        a2na3iimag = (a2 - a3) * IIMAG % MOD
                        a[i + offset][j] = (a0 + a1 + a2 + a3) % MOD
                        a[i + offset + p][j] = (a0 - a1 + a2na3iimag) * irot % MOD
                        a[i + offset + p * 2][j] = (a0 + a1 - a2 - a3) * irot2 % MOD
                        a[i + offset + p * 3][j] = (a0 - a1 - a2na3iimag) * irot3 % MOD
                irot *= irate3[(~s & -~s).bit_length()]
                irot %= MOD
            le -= 2
    n, m = m, n
    h = (n - 1).bit_length()
    le = h
    while le:
        if le == 1:
            p = 1 << (h - le)
            irot = 1
            for s in range(1 << (le - 1)):
                offset = s << (h - le + 1)
                for i in range(p):
                    for j in range(m):
                        l = a[j][i + offset]
                        r = a[j][i + offset + p]
                        a[j][i + offset] = (l + r) % MOD
                        a[j][i + offset + p] = (l - r) * irot % MOD
                irot *= irate2[(~s & -~s).bit_length()]
                irot %= MOD
            le -= 1
        else:
            p = 1 << (h - le)
            irot = 1
            for s in range(1 << (le - 2)):
                irot2 = irot * irot % MOD
                irot3 = irot2 * irot % MOD
                offset = s << (h - le + 2)
                for i in range(p):
                    for j in range(m):
                        a0 = a[j][i + offset]
                        a1 = a[j][i + offset + p]
                        a2 = a[j][i + offset + p * 2]
                        a3 = a[j][i + offset + p * 3]
                        a2na3iimag = (a2 - a3) * IIMAG % MOD
                        a[j][i + offset] = (a0 + a1 + a2 + a3) % MOD
                        a[j][i + offset + p] = (a0 - a1 + a2na3iimag) * irot % MOD
                        a[j][i + offset + p * 2] = (a0 + a1 - a2 - a3) * irot2 % MOD
                        a[j][i + offset + p * 3] = (a0 - a1 - a2na3iimag) * irot3 % MOD
                irot *= irate3[(~s & -~s).bit_length()]
                irot %= MOD
            le -= 2
    iv = pow(n * m, MOD - 2, MOD)
    for i in range(m):
        for j in range(n):
            a[i][j] = a[i][j] * iv % MOD

def multiply2d(s: list[list], t: list[list]):
    """
    not verify
    """
    from copy import deepcopy
    hs, ws = len(s), len(s[0])
    ht, wt = len(t), len(t[0])
    h = 1 << (hs + ht - 2).bit_length()
    w = 1 << (ws + wt - 2).bit_length()
    a = deepcopy(s)
    b = deepcopy(t)
    for i in range(hs):
        a[i] += [0] * (w - ws)
    for i in range(ht):
        b[i] += [0] * (w - wt)
    a += [[0]*w for i in range(h - hs)]
    b += [[0]*w for i in range(h - ht)]
    intt2d(a)
    intt2d(b)
    for i in range(h):
        for j in range(w):
            a[i][j] *= b[i][j]
            a[i][j] %= MOD
    intt2d(a)
    a = a[:hs + ht - 1]
    for i in range(hs + ht - 1):
        a[i][ws + wt - 1:] = []
    return a

n, k = MI()

p = pow(5, - 4 * n, mod)
q = pow(5,  - 4 * (n + 1), mod)


g = [0] * (4 * n + 4 + 1)
g[4 * n] = p
g[4 * n + 4] = -q

f = [0] * (4 * n + 4 + 1)
f[0] = 1
f[1] = -1
f[4 * n + 1] = p
f[4 * n + 4] = -q

res = LinearRecurrence(k, g, f)
print(res)