{-# LANGUAGE TypeFamilies, BangPatterns, FlexibleContexts, BangPatterns #-}
import Data.Array
import Data.Array.Unboxed
import qualified Data.Array.Unboxed as UA
import Data.Array.IO
import Data.Array.Unsafe
import qualified Data.Map.Strict as M
import qualified Data.Set as S
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Unboxed.Mutable as U
import Data.Int
import Control.Monad.State.Strict hiding(foldM)
import qualified Data.ByteString.Char8 as B
import Data.ByteString(ByteString)
import Data.Char
import Debug.Trace
import Data.List(sort)

type Scanner a = StateT ByteString IO a
type family Freeze a where
  Freeze (IOUArray i v) = UArray i v
  Freeze (IOArray i v) = Array i v

foldM :: Monad m => (b -> a -> m b) -> b -> [a] -> m b
foldM f z0 xs = foldr c return xs z0
    where c x k = \z -> f z x >>= k
          {-# INLINE c #-}

scan :: Read a => Scanner a
scan = state $ \s ->
    let (s1, s2) = B.span (not . isSpace) s 
        !v = read (B.unpack s1)
    in (v, B.dropWhile isSpace s2)

scanInt :: Scanner Int
scanInt = scan

scanString :: Scanner B.ByteString
scanString = state $ \s ->
    let (s1, s2) = B.span (not . isSpace) s in
    (s1, B.dropWhile isSpace s2)

scanReal :: Scanner Double
scanReal = scan

main :: IO ()
main = B.getContents >>= \content -> flip evalStateT content $ do
    vN <- scanInt
    vX <- scanInt
    vS <- lift $ newArray_ (1, vN) :: Scanner (IOUArray Int Int)
    forM_ [1..vN] $ \i0 -> do
        scanInt >>= lift . writeArray vS (i0)
    vS <- lift $ unsafeFreeze vS 
    liftIO $ solve vN vX vS

newtype M = M Int
    deriving Show

modulo = 1000000007

instance Num M where
    M a + M b = M $ (a + b) `mod` modulo
    M a - M b = M $ (a - b) `mod` modulo
    M a * M b = M $ (a * b) `mod` modulo
    fromInteger x = M $ fromInteger x `mod` modulo
    abs = id
    signum _ = M 1

instance Fractional M where
    recip (M x) = M (recipM x modulo)

data EGCD = EGCD !Int !Int !Int

{-# NOINLINE recipM #-}
recipM :: Int -> Int -> Int
recipM x m | g /= 1 = error $ "No inverse for " ++ show x ++ " % " ++ show m 
           | s <  0 = s + m
           | otherwise = s
    where 
    EGCD s _ g = extgcd x m

extgcd :: Int -> Int -> EGCD
extgcd = go
    where 
    go a 0 = EGCD 1 0 a
    go a b = EGCD t (s - q * t) g
        where
        (q, r) = quotRem a b
        EGCD s t g = go b r

solve :: Int -> Int -> Freeze (IOUArray Int Int) -> IO ()
solve vN vX vS = print ans
    where
    sorted = sort $ UA.elems vS 
    s0 = U.generate (vX+1) id 
    M ans = M (sn U.! vX) * product (map M [1..vN])
    step !tbl (k, y) = 
        let !p1 = recip $ M k
            !p2 = 1 - p1 in
        U.generate (vX+1) $ \x ->
            let v1 = tbl U.! (x `mod` y)
                v2 = tbl U.! x
                M v = M v1 * p1 + M v2 * p2
            in v
    sn = foldl step s0 $ zip [1..vN] sorted
