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.

Examples

Input

2 19
3 7


Output

3


Input

5 82
22 11 6 5 13


Output

288


Input

10 100000
50000 50001 50002 50003 50004 50005 50006 50007 50008 50009


Output

279669259
import java.util.*;

public class Main {
    public static void main(String[] args) {
        int mod = 1000000007;
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x = sc.nextInt();
        int[] s = new int[n];
        for(int i=0;i<n;i++) s[i] = sc.nextInt();
        Arrays.sort(s);
        int index = 0;
        long[] dp = new long[x+1];
        for(int v=0;v<x+1;v++) dp[v] = 0;
        for(int v=1;v<x+1;v++) {
            while(index < n && s[index] <= v) {
                index++;
            }
            // System.out.println(index);
            if(index == 0) {
                dp[v] = v%mod;
                // System.out.println(dp[v]);
            } else {
                for(int i=0;i<index;i++) {
                    int res = v%s[i];
                    dp[v] += dp[res];
                    dp[v] %= mod;
                }
            }
            if(index > 0) {
                int divideBy = modPow(index,mod-2,mod);
                dp[v] *= divideBy;
                dp[v] %= mod;
            }
        }
        int coeff = 1;
        for(int v=1;v<n+1;v++) {
            coeff = modProd(coeff,v,mod);
        }
        // long ans = dp[x] * coeff;
        int ans = modProd((int) dp[x],coeff,mod);
        // ans %= mod;
        System.out.println(ans);
        // System.out.println("dp table");
        // for(int v=0;v<x+1;v++) {
            // System.out.println(dp[v]);
        // }
        // int value = modPow(2, mod-2, mod);
        // int w = modProd(3,value,mod);

        // int y = modProd(w,(int) coeff,mod);
        // System.out.println(coeff);
        // System.out.println(w);
        // System.out.println(y);
    }
    public static int modProd(int x,int y,int mod){
        long xx = (long) x;
        long yy = (long) y;
        long v = xx * yy;
        v %= mod;
        return((int) v);
    }
    public static int modPow(int value,int exponent,int mod) {
        if (exponent == 0) return(1);
        if (exponent == 1) return(value%mod);
        long longValue = (long) value;
        int res = exponent%2;
        int q = exponent/2;
        long answer = 1;
        if(res == 1) answer *= longValue;
        longValue *= longValue;
        longValue %= mod;
        answer = (answer * ((long) modPow((int) longValue, q, mod)))%mod;
        return((int) answer);
    }
}   