Buggy python submission (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()


Fixed submission:
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007


# 挿入dp
def solve():
    n,x = LI()
    s = LI()
    s.sort()
    dp = [[0]*(x+1) for i in range(n+1)] # dp[i][j] := スタート時点の値がjの時に最初のi個の順列すべてを試し、えられる総和
    for j in range(x+1):
        dp[0][j] = j # dpの定義より明らか
        for i in range(n):
            si = s[i]
            ni = i+1
            nd = dp[i][j%si] # 先頭にsiを挿入 (スタートの値がj%siとなる)
            nd += i*dp[i][j] # 先頭以外にsiを挿入 (スタートの値も間の値も変わらない)
            dp[ni][j] += nd
            if dp[ni][j] >= mod:
                dp[ni][j] %= mod
    print(dp[n][x])
    return

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

Buggy python submission (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()


Fixed submission:
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007


# 挿入dp
def solve():
    n,x = LI()
    s = LI()
    s.sort()
    dp = [[0]*(x+1) for i in range(n+1)] # dp[i][j] := スタート時点の値がjの時に最初のi個の順列すべてを試し、えられる総和
    for j in range(x+1):
        dp[0][j] = j # dpの定義より明らか
        for i in range(n):
            si = s[i]
            ni = i+1
            nd = dp[i][j%si] # 先頭にsiを挿入 (スタートの値がj%siとなる)
            nd += i*dp[i][j] # 先頭以外にsiを挿入 (スタートの値も間の値も変わらない)
            dp[ni][j] += nd
            if dp[ni][j] >= mod:
                dp[ni][j] %= mod
    print(dp[n][x])
    return

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

Buggy python submission (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
def D():
    def dfs(d,x,k,ans):
        if x < m:
            ans += [x*fact[n-d]%mod]
        else:
            for i in range(len(k)):
                dfs(d+1,x%k[i],k[:i]+k[i+1:],ans)
    n,x = LI()
    s = LI()
    m = min(s)
    fact = [1 for i in range(n+1)]
    for i in range(n):
        fact[i+1] = fact[i]*(i+1)%mod
    ans = []
    k = [s[i] for i in range(n)]
    dfs(0,x,k,ans)
    print(sum(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()


Fixed submission:
#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007


# 挿入dp
def solve():
    n,x = LI()
    s = LI()
    s.sort()
    dp = [[0]*(x+1) for i in range(n+1)] # dp[i][j] := スタート時点の値がjの時に最初のi個の順列すべてを試し、えられる総和
    for j in range(x+1):
        dp[0][j] = j # dpの定義より明らか
        for i in range(n):
            si = s[i]
            ni = i+1
            nd = dp[i][j%si] # 先頭にsiを挿入 (スタートの値がj%siとなる)
            nd += i*dp[i][j] # 先頭以外にsiを挿入 (スタートの値も間の値も変わらない)
            dp[ni][j] += nd
            if dp[ni][j] >= mod:
                dp[ni][j] %= mod
    print(dp[n][x])
    return

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