main = do
    [n,s] <- map read . words <$> getLine
    a <- map read . words <$> getLine
    print $ solve a s

solve :: [Integer] -> Int -> Integer
solve a s = (getList $ foldl1 (<++>) (calcFs a)) !! s

calcFs :: [Integer] -> [Formalpowerseries Integer]
calcFs [] = [addEmpty]
calcFs (a:as) = let all@(a':as') = calcFs as
                    a'' = a' <++> mulEmpty in (a'' <++> shiftR a'' a):all

shiftR ::Formalpowerseries Integer -> Integer -> Formalpowerseries Integer
shiftR a r = Formalpowerseries $ replicate (fromInteger r) 0 ++ (getList a)

newtype Formalpowerseries a = Formalpowerseries { getList :: [a] } deriving(Show)

instance Modint a => Group (Formalpowerseries a) where
    a <++> b = Formalpowerseries $ zipWith (+%) (getList a) (getList b)
    addEmpty = Formalpowerseries $ repeat 0
    addInv a = Formalpowerseries $ map (*(-1)) (getList a)

instance Modint a => Ring (Formalpowerseries a) where
    a <**> b = Formalpowerseries $ map (mul a b) [1..]
    mulEmpty = Formalpowerseries $ 1:(repeat 0)

mul :: Modint a => Formalpowerseries a -> Formalpowerseries a -> Int -> a
mul a b k = foldl1 (+%) $ zipWith (*%) (take k $ getList a) (reverse $ take k $ (getList b))

class Group a where
    (<++>) :: a -> a -> a
    addEmpty :: a
    addInv :: a -> a

class Group a => Ring a where
    (<**>) :: a -> a -> a
    mulEmpty :: a

class Ring a => Field a where
    mulInv :: a -> a

instance Group Int where
    a <++> b = a + b
    addEmpty = 0
    addInv a = -a

instance Ring Int where
    a <**> b = a * b
    mulEmpty = 1

class (Integral a) => Modint a where
    p :: a
    modp :: a -> a
    (+%) :: a -> a -> a
    (-%) :: a -> a -> a
    (*%) :: a -> a -> a
    (^%) :: a -> a -> a
    inv :: a -> a
    (/%) :: a -> a -> a

instance Modint Integer where
    p = 998244353
    modp a = mod a p
    a +% b = modp $ a+b
    a -% b = modp $ a-b
    a *% b = modp $ a*b
    a ^% 0 = 1
    a ^% x = let aa = modp $ (a ^% (div x 2)) ^ 2 in aa *% (a ^ (mod x 2))
    inv a = a ^% (p-2)
    a /% b = a *% (inv b)
