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 Scala (2.11.7) (judge verdict: Time Limit Exceeded)

import java.util.Scanner

object Main {


  case class RR(representative: Long) extends AnyVal {
    def +(that: RR): RR = RR((this.representative + that.representative) % RR.mod)

    def -(that: RR): RR = RR((this.representative - that.representative + RR.mod) % RR.mod)

    def *(that: RR): RR = RR((this.representative * that.representative) % RR.mod)

    def unary_- : RR = RR((-this.representative + RR.mod) % RR.mod)
  }


  object RR {
    val mod: Long = (1e9+7).toLong

    val _0: RR = RR(0)
    val _1: RR = RR(1)
  }

  def read() = {
    val sc = new Scanner(System.in)
    val n, x = sc.nextInt()
    val s = for (_ <- 0 until n) yield sc.nextInt()
    (n, x, s.sorted)
  }


  def solve2(n: Int, x: Int, s: IndexedSeq[Int]): Long = {
    val ss = s.sorted
    val maxY = Math.max(x, ss.max)
    // dp: [0, n) * [0, maxY] => [0, infty)
    // dp(i, y) = (0 to i).map(ss).permutations.map(t => t.foldLeft(y)(_%_)).sum
    // dp(0, y) = y mod ss(0)
    // dp(i, y) = (i - 1) * dp(i - 1, y) + dp(i - 1, y mod ss(i))

    val initDP = IndexedSeq.tabulate(maxY + 1)(y => RR(y % ss(0)))
    val resultDP = (1 until n).foldLeft(initDP)((dp, i) =>
      IndexedSeq.tabulate(dp.length)(y => RR(i) * dp(y) + dp(y % ss(i)))
    )
    resultDP(x).representative
  }


  def main(args: Array[String]): Unit = {
    val (n, x, s) = read()
    println(solve2(n, x, s))
  }


  // ---以下実験用---

  // O(n!)愚直解
  def solve(n: Int, x: Int, s: IndexedSeq[Int]): Long = {
    s.permutations.map(t => t.foldLeft(x)(_ % _)).sum
  }

  def experiment(n: Int, x: Int, s: IndexedSeq[Int]): Unit = {
    s.permutations.map(t => (t, t.scanLeft(x)(_ % _))).foreach(println)
    s.permutations.map(t => (t, t.foldLeft(x)(_ % _))).foreach(println)
    s.permutations.map(t => t.foldLeft(x)(_ % _)).toIndexedSeq.groupBy(identity).map { case (e, xs) => (e, xs.length) }.foreach(println)
  }

  def experiment2(): Unit = {
    val n = 5
    val s = IndexedSeq(22, 11, 6, 5, 13)
    (0 until 200).foreach { x =>
      println(s"x=$x")
      s.permutations.map(t => t.foldLeft(x)(_ % _)).toIndexedSeq.groupBy(identity).map { case (e, xs) => (e, xs.length) }.foreach(println)
      println()
    }
  }

  def experiment3(): Unit = {
    val n = 5
    val s = IndexedSeq(22, 11, 6, 5, 13)
    (0 until 200).foreach { x =>
      println(s"x=$x, ans: ${solve(n, x, s)}")
    }
  }
}