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

#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
sys.setrecursionlimit(1000000)
mod = 1000000007

#A
def A():
    a,b,c = LI()
    if a == b and b == c:
        print("Yes")
    else:
        print("No")
    return

#B
def B():
    n = I()
    s = S()
    r = s.count("R")
    if r > n//2:
        print("Yes")
    else:
        print("No")
    return

#C
def C():
    n,q = LI()
    s = S()

    return

#D
fact = [1 for i in range(200+1)]
for i in range(200):
    fact[i+1] = fact[i]*(i+1)%mod
ans = 0
def dfs(d,x,k,m,n):
    global ans
    if x < m:
        ans += x*fact[n-d]%mod
        ans %= mod
    else:
        for i in range(len(k)):
            dfs(d+1,x%k[i],k[:i]+k[i+1:],m,n)
def D():
    n,x = LI()
    s = LI()
    m = min(s)
    k = [s[i] for i in range(n)]
    dfs(0,x,k,m,n)
    print(ans%mod)
    return

#E
def E():
    def com(a,b):
        return fact[a]*inv[b]*inv[a-b]%mod
    fact = [1 for i in range(100001)]
    for i in range(100000):
        fact[i+1] = fact[i]*(i+1)%mod
    inv = [1 for i in range(100001)]
    inv[100000] = pow(fact[100000],mod-2,mod)
    for i in range(100000)[::-1]:
        inv[i] = inv[i+1]*(i+1)%mod
    b,w = LI()
    n = b+w
    po = [1 for i in range(100001)]
    for i in range(100000):
        po[i+1] = po[i]*2%mod
    inp = [1 for i in range(100001)]
    inp[100000] = pow(po[100000],mod-2,mod)
    for i in range(100000)[::-1]:
        inp[i] = inp[i+1]*2%mod
    for i in range(1,n+1):
        ans = 0
        if i < n:
            if i < b:
                for k in range(1,i+1):
                    ans += inp[i]*com(i-1,k-1)%mod
                    ans %= mod
            else:
                for k in range(1,b):
                    ans += inp[i]*com(i-1,k-1)%mod
                    ans %= mod
                for k in range(b,i+1):
                    ans += inp[i-1]*com(i-1,k-1)%mod
                    ans %= mod
        else:
            for k in range(n-w+1,b):
                ans += inp[i]*com(i-1,k-1)%mod
                ans %= mod
            for k in range(b,i):
                ans += inp[i-1]*com(i-1,k-1)%mod
                ans %= mod
            ans *= inp[i-2]*com(i-1,k-1)%mod
            ans %= mod
        print(ans)
        print
    return

#F
def F():
    return

#G
def G():
    return

#H
def H():
    return

#Solve
if __name__ == "__main__":
    D()