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 C# (Mono 4.6.2.0) (judge verdict: Time Limit Exceeded)

using System;
using System.Linq;

namespace Exa2019_D
{
    class Program
    {
        static int mod = 1000000007;
        static int[,] modlist;
        static int ans;

        static void Main(string[] args)
        {
            var maxS = 100001;
            var NX = Console.ReadLine().Split().Select(int.Parse).ToArray();
            var N = NX[0];
            var X = NX[1];
            var S = Console.ReadLine().Split().Select(int.Parse).ToArray();

            Array.Sort(S);


            permutation(new int[0], S, X);

            Console.WriteLine(ans);
        }

        static void permutation(int[] left, int[] right, int X)
        {
            int[] newLeft = new int[left.Length + 1];
            for (int i = 0; i < left.Length; i++)
            {
                newLeft[i] = left[i];
            }


            for (int i = 0; i < right.Length; i++)
            {
                newLeft[newLeft.Length - 1] = right[i];
                var newX = CalcMod(X, right[i]);

                if (right.Length == 1)
                {
                    ans += newX;
                    if (ans >= mod) ans -= mod;
                }
                else
                {
                    var min = i == 0 ? right[1] : right[0];
                    if (newX < min)
                    {
                        var tempSum = newX;
                        for (int j = 2; j <= right.Length - 1; j++)
                        {
                            tempSum *= j;
                            if (tempSum >= mod) tempSum %= mod;
                        }

                        ans += tempSum;
                        if (ans >= mod) ans -= mod;
                    }
                    else
                    {
                        var newRight = new int[right.Length - 1];
                        for (int j = 0; j < i; j++)
                        {
                            newRight[j] = right[j];
                        }

                        for (int j = i + 1; j < right.Length; j++)
                        {
                            newRight[j - 1] = right[j];
                        }

                        permutation(newLeft, newRight, newX);
                    }
                }
            }
        }

        private static int CalcMod(int v1, int v2)
        {
            if (v1 < v2) return v1;
            return v1 % v2;
        }
    }
}