{-# 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 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

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

solve :: Int -> Int -> Freeze (IOUArray Int Int) -> IO ()
solve vN vX vS = do
    memo <- newArray ((0,1), (vX, vN)) (-1) :: IO (IOUArray (Int,Int) Int)
    let ss = S.fromList $ UA.elems vS
    let f x 0 = return x
        f x k = do
            v <- readArray memo (x, k) 
            if v /= -1 then return v else do
                let l = fst $ S.split (x+1) ss
                v1 <- foldM (\a y -> do
                    r <- f (x `mod` y) (k - 1)
                    return $ addM a r) 0 $ S.toList l
                v2 <- f x (k - 1)
                let v = v1 `addM` (v2 `mulM`(k - S.size l))
                writeArray memo (x, k) v
                return v
    ans <- f vX vN
    print ans
    where
    modulo = 1000000007
    addM a b = (a + b) `mod` modulo
    mulM a b = (a * b) `mod` modulo
    {-
    s0 = U.generate (vX+1) id 
    ans = sn U.! vX
    step !acc k = U.generate (vX+1) $ \x ->
        let l = filter (<= x) $ UA.elems vS
            v1 = foldl addM 0 [ acc U.! (x `mod` y) | y <- l ]
        in v1 `addM` ((acc U.! x) `mulM` (k - length l))
    sn = foldl step s0 [1..vN]
    -}
