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 BangPatterns       #-}
{-# LANGUAGE DataKinds          #-}
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE KindSignatures     #-}
{-# LANGUAGE TypeOperators      #-}
-- module ExaWizards2019.D (main) where

import           Control.Exception (assert)
import           Data.Bifunctor    (bimap)
import           Data.List         (foldl', sort)
import           Data.Map          (Map, (!))
import qualified Data.Map          as M (empty, foldlWithKey, insert)
import           Data.Ratio        (denominator, numerator)
import           Data.Vector       (Vector)
import qualified Data.Vector       as V (generate, (!))
import           GHC.TypeLits      (type (+), KnownNat, Nat, type (^), natVal)

main :: IO ()
main = do
  [n, x] <- map read . words <$> getLine
  ss <- map read . words <$> getLine
  assert (length ss == n) $
    print $ solve' n x ss

type M = Modular Int (10 ^ 9 + 7)

type Table = Map Int M

solve :: Int -> Int -> [Int] -> M
solve n x ss = fact n * foldl' f M.empty set ! x
  where
    set :: [(M, Int)]
    set = bimap fromIntegral id <$> zip [1..] (sort ss)

    f :: Table -> (M, Int) -> Table
    f table (i, s) =
      let
        p1 = 1 / i
        p2 = 1 - p1

        step table' k b =
          let
            n1 = table ! (k `mod` s)
            n2 = b
          in
            M.insert k (p1 * n1 + p2 * n2) table'
      in
        M.foldlWithKey step M.empty table

solve' :: Int -> Int -> [Int] -> M
solve' n x ss = fact n * (foldl step table0 set V.! x)
  where
    set :: [(Int, Int)]
    set = zip [1..n] $ sort ss

    table0 :: Vector M
    table0 = V.generate (x + 1) fromIntegral

    step :: Vector M -> (Int, Int) -> Vector M
    step !table (i, y) =
      let
        !p1 = recip $ fromIntegral i
        !p2 = 1 - p1
      in
        V.generate (x + 1) $ \x' ->
            let
              n1 = table V.! (x' `mod` y)
              n2 = table V.! x'
            in
              p1 * n1 + p2 * n2

fact :: Int -> M
fact n = product $ map fromIntegral [1 .. n]

-- modular

newtype Modular a (modulus :: Nat) =
  Modular { unModular :: a }
  deriving (Eq)

instance Show a => Show (Modular a modulus) where
  show (Modular n) = show n

instance (Integral a, KnownNat modulus) => Num (Modular a modulus) where
  fromInteger           = toModular . fromInteger
  Modular n + Modular m = toModular $ n + m
  Modular n * Modular m = toModular $ n * m
  negate (Modular n)    = toModular $ negate n
  abs (Modular n)       = toModular $ abs n
  signum (Modular n)    = toModular $ signum n

instance (Integral a, KnownNat modulus) => Fractional (Modular a modulus) where
  recip m@(Modular n) = toModular $ modularReciprocal (fromInteger (natVal m)) n
  fromRational r = fromInteger (numerator r) / fromInteger (denominator r)

toModular :: (Integral a, KnownNat modulus) => a -> Modular a modulus
toModular n = let m = Modular $ n `mod` fromInteger (natVal m) in m

modularReciprocal :: Integral a => a -> a -> a
modularReciprocal modulus n = snd $ modularReciprocal' modulus n
  where
    -- modularReciprocal' n m = (x, y)
    -- n * x + m * y = 1
    modularReciprocal' _ 0 = notCoprimeError
    modularReciprocal' _ 1 = (0, 1)
    modularReciprocal' m l = (y, x - q * y)
      where
        (q, r) = m `divMod` l
        (x, y) = modularReciprocal' l r
    notCoprimeError =
      error $ unwords
        [ "divider"
        , parentheses $ showIntegral n
        , "must be coprime to modulus"
        , parentheses $ showIntegral modulus
        ]
    parentheses s = "(" ++ s ++ ")"
    showIntegral = show . toInteger