from typing import List

def bsf(x):
    res = 0
    while not (x & 1):
        res += 1
        x >>= 1
    return res

P = 943718401
G = 7
rank2 = bsf(P - 1)

class NTT:
    class __RootInitializer:
        @staticmethod
        def root():
            return [pow(G, (P - 1) >> i, P) for i in range(0, rank2 + 1)]

        @staticmethod
        def iroot():
            return [pow(pow(G, P - 2, P), (P - 1) >> i, P) for i in range(0, rank2 + 1)]

    root = __RootInitializer.root()
    iroot = __RootInitializer.iroot()

    class __RateInitializer:
        @staticmethod
        def rates(root: List[int], iroot: List[int]):
            rate2 = [0] * max(0, rank2 - 1)
            irate2 = [0] * max(0, rank2 - 1)
            prod = iprod = 1
            for i in range(rank2 - 1):
                rate2[i] = root[i + 2] * prod % P
                irate2[i] = iroot[i + 2] * iprod % P
                prod = prod * iroot[i + 2] % P
                iprod = iprod * root[i + 2] % P
            
            rate3 = [0] * max(0, rank2 - 2)
            irate3 = [0] * max(0, rank2 - 2)
            prod = iprod = 1
            for i in range(rank2 - 2):
                rate3[i] = root[i + 3] * prod % P
                irate3[i] = iroot[i + 3] * iprod % P
                prod = prod * iroot[i + 3] % P
                iprod = iprod * root[i + 3] % P
            return rate2, irate2, rate3, irate3
    
    rate2, irate2, rate3, irate3 = __RateInitializer.rates(__RootInitializer.root(), __RootInitializer.iroot())

    @staticmethod
    def butterfly(a: List[int]) -> None:
        n = len(a)
        h = bsf(n)
        l = 0
        while l < h:
            if h - l == 1:
                p = 1 << (h - l - 1)
                rot = 1
                for s in range(1 << l):
                    offset = s << (h - l)
                    for i in range(p):
                        u = a[i + offset]
                        v = a[i + offset + p] * rot
                        a[i + offset] = (u + v) % P
                        a[i + offset + p] = (u - v) % P
                    if s + 1 != 1 << l:
                        rot = rot * NTT.rate2[bsf(~s)] % P
                l += 1
            else:
                p = 1 << (h - l - 2)
                rot, imag = 1, NTT.root[2]
                for s in range(1 << l):
                    rot2 = rot * rot % P
                    rot3 = rot2 * rot % P
                    offset = s << (h - l)
                    for i in range(p):
                        a0 = a[i + offset]
                        a1 = a[i + offset + p] * rot
                        a2 = a[i + offset + 2 * p] * rot2
                        a3 = a[i + offset + 3 * p] * rot3
                        a1na3imag = (a1 - a3) % P * imag
                        a[i + offset] = (a0 + a2 + a1 + a3) % P
                        a[i + offset + 1 * p] = (a0 + a2 - a1 - a3) % P
                        a[i + offset + 2 * p] = (a0 - a2 + a1na3imag) % P
                        a[i + offset + 3 * p] = (a0 - a2 - a1na3imag) % P
                    if s + 1 != (1 << l):
                        rot = rot * NTT.rate3[bsf(~s)] % P
                l += 2

    @staticmethod
    def butterfly_inv(a : List[int]) -> None:
        n = len(a)
        h = bsf(n)

        l = h
        while l:
            if l == 1:
                p = 1 << (h - l)
                irot = 1
                for s in range(1 << (l - 1)):
                    offset = s << (h - l + 1)
                    for i in range(p):
                        u = a[i + offset]
                        v = a[i + offset + p]
                        a[i + offset] = (u + v) % P
                        a[i + offset + p] = ((u - v) * irot) % P
                    if s + 1 != 1 << (l - 1):
                        irot = irot * NTT.irate2[bsf(~s)] % P
                l -= 1
            else:
                p = 1 << (h - l)
                irot = 1
                iimag = NTT.iroot[2]
                for s in range(1 << (l - 2)):
                    irot2 = irot * irot % P
                    irot3 = irot2 * irot % P
                    offset = s << (h - l + 2)
                    for i in range(p):
                        a0 = a[i + offset]
                        a1 = a[i + offset + p]
                        a2 = a[i + offset + 2 * p]
                        a3 = a[i + offset + 3 * p]

                        a2na3iimag = (a2 - a3) * iimag % P

                        a[i + offset] = (a0 + a1 + a2 + a3) % P
                        a[i + offset + p] = ((a0 - a1 + a2na3iimag) * irot) % P
                        a[i + offset + 2 * p] = ((a0 + a1 - a2 - a3) * irot2) % P
                        a[i + offset + 3 * p] = ((a0 - a1 - a2na3iimag) * irot3) % P
                    if s + 1 != 1 << (l - 2):
                        irot = irot * NTT.irate3[bsf(~s)] % P
                l -= 2
    
    @staticmethod
    def convolution(a, b):
        n = len(a)
        m = len(b)
        if not a or not b:
            return []
        if min(n, m) <= 40:
            if n < m:
                n, m = m, n
                a, b = b, a
            res = [0] * (n + m - 1)
            for i in range(n):
                for j in range(m):
                    res[i + j] += a[i] * b[j]
                    res[i + j] %= P
            return res
        z = 1 << ((n + m - 1).bit_length())

        iz = pow(z, P - 2, P)
        a += [0] * (z - n)
        b += [0] * (z - m)
        NTT.butterfly(a)
        NTT.butterfly(b)
        c = [a[i] * b[i] % P * iz % P for i in range(z)]
        NTT.butterfly_inv(c)
        return c[:n + m - 1]

n, x = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))

if x == 0:
    ans = sum(A[i] * B[i] % P * C[0] % P for i in range(n + 1)) + sum(A[i] * B[0] % P * C[i] % P for i in range(1, n + 1))
    print(ans % P)
else:
    def enumerate_powers(x, n):
        x2 = x * x % P
        pow_x2 = 1 # x ** (2i)
        y = 1      # x ** (i(i + 1))
        z = 1      # x ** t(i)

        yield z

        for _ in range(n):
            yield z

            pow_x2 = pow_x2 * x2 % P
            y = y * pow_x2 % P
            z = z * y % P

    t = lambda k : (k - 1) * k * (k + 1) // 3

    inv_x = pow(x, P - 2, P)

    pows_inv_x = list(enumerate_powers(inv_x, n))
    pows_x = list(enumerate_powers(x, n))

    F = [B[i] * pows_inv_x[i] % P for i in range(n + 1)]
    G = [C[i] * pows_inv_x[i] % P for i in range(n + 1)]

    H = NTT.convolution(F, G)

    ans = sum(A[i] * pows_x[i] % P * H[i] % P for i in range(n + 1))

    print(ans % P)