Problem:
Score : 600 points

Problem Statement

Snuke has a blackboard and a set S consisting of N integers.
The i-th element in S is S_i.

He wrote an integer X on the blackboard, then performed the following operation N times:

Choose one element from S and remove it.

Let x be the number written on the blackboard now, and y be the integer removed from S. Replace the number on the blackboard with x \bmod {y}.

There are N! possible orders in which the elements are removed from S.
For each of them, find the number that would be written on the blackboard after the N operations, and compute the sum of all those N! numbers modulo 10^{9}+7.

Constraints

All values in input are integers.

1 \leq N \leq 200

1 \leq S_i, X \leq 10^{5}

S_i are pairwise distinct.

Input

Input is given from Standard Input in the following format:

N X
S_1 S_2 \ldots S_{N}

Output

Print the answer.

Sample Input 1

2 19
3 7

Sample Output 1

3

There are two possible orders in which we remove the numbers from S.

If we remove 3 and 7 in this order, the number on the blackboard changes as follows: 19 \rightarrow 1 \rightarrow 1.

If we remove 7 and 3 in this order, the number on the blackboard changes as follows: 19 \rightarrow 5 \rightarrow 2.

The output should be the sum of these: 3.

Sample Input 2

5 82
22 11 6 5 13

Sample Output 2

288

Sample Input 3

10 100000
50000 50001 50002 50003 50004 50005 50006 50007 50008 50009

Sample Output 3

279669259

Be sure to compute the sum modulo 10^{9}+7.

Solution in Haskell (GHC 7.10.3) (judge verdict: Time Limit Exceeded)

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