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.Collections.Generic;
using System.Linq;

namespace MoculoOperations
{
    internal class Program
    {
        private const long m = 1000000007;
        private static void Main(string[] args)
        {
            int x;
            HashSet<int> ss;
            GetInput(out x, out ss);
            //DateTime st = DateTime.Now;
            var cache = new Dictionary<int, Dictionary<HashSet<int>, long>>();
            Console.WriteLine(Solve(x, ss,cache));
            //Console.WriteLine(DateTime.Now - st);
            //Console.ReadKey();
        }

        private static long FactorialMod(int n)
        {
            long ret = 1;
            for (int i = 2; i <= n; i++)
            {
                ret = (ret * i) % m;
            }
            return ret;
        }

        private static long Solve(int x, HashSet<int> ss)
        {
            if (ss.Count == 0)
            {
                return x;
            }
            else if (x == 1)
            {
                return FactorialMod(ss.Count);
            }
            else if (ss.All(k => k > x))
            {
                return (x * FactorialMod(ss.Count)) % m;

            }
            else
            {
                long ret = 0;
                foreach (int y in ss)
                {
                    HashSet<int> newSs = new HashSet<int>();
                    int newX = x % y;
                    foreach (int s in ss)
                    {
                        if (s != y)
                        {
                            newSs.Add(s);
                        }
                    }
                    ret = (ret + Solve(newX, newSs)) % m;
                }
                return ret;
            }
        }

        private static long Solve(int x, HashSet<int> ss, Dictionary<int, Dictionary<HashSet<int>, long>> cache)
        {
            if (ss.Count == 0)
            {
                return x;
            }
            else if (x == 1)
            {
                return FactorialMod(ss.Count);
            }
            else if (ss.All(k => k > x))
            {
                return (x * FactorialMod(ss.Count)) % m;

            }
            if (cache.ContainsKey(x) && cache[x].ContainsKey(ss))
            {
                return cache[x][ss];
            }
            else
            {

                long ret = 0;
                foreach (int y in ss)
                {
                    HashSet<int> newSs = new HashSet<int>();
                    int newX = x % y;
                    foreach (int s in ss)
                    {
                        if (s != y)
                        {
                            newSs.Add(s);
                        }
                    }
                    ret = (ret + Solve(newX, newSs)) % m;
                }

                if (!cache.ContainsKey(x))
                {
                    cache[x] = new Dictionary<HashSet<int>, long>(new Comparer());
                }
                cache[x][ss] = ret;

                return ret;
            }
        }

        private class Comparer : IEqualityComparer<HashSet<int>>
        {
            public bool Equals(HashSet<int> x, HashSet<int> y)
            {
                return x.Count == y.Count && x.All(item => y.Contains(item));
            }

            public int GetHashCode(HashSet<int> obj)
            {
                int ret = 0;
                foreach (int n in obj)
                {
                    ret ^= 1 << (n % 31);
                }
                return ret;
            }
        }

        private static void GetInput(out int x, out HashSet<int> ss)
        {
            string[] items = Console.ReadLine().Split(' ');
            x = int.Parse(items[1]);
            ss = new HashSet<int>(Console.ReadLine().Split(' ').Select(item => int.Parse(item)));

        }

     

    }
}