// Not afraid to dark.

#include <bits/stdc++.h>
using namespace std;

#define int long long

namespace io {
    int read_pos, read_dt; char read_char;
    inline int read (int &p = read_pos){
        p = 0, read_dt = 1; read_char = getchar ();
        while (! isdigit (read_char)){
            if (read_char == '-')
                read_dt = - 1;
            read_char = getchar ();
        }
        while (isdigit (read_char)){
            p = (p << 1) + (p << 3) + read_char - 48;
            read_char = getchar ();
        }
        return p = p * read_dt;
    }
    int write_sta[65], write_top;
    inline void write (int x){
        if (x < 0)
            putchar ('-'), x = - x;
        write_top = 0;
        do
            write_sta[write_top ++] = x % 10, x /= 10;
        while (x);
        while (write_top)
            putchar (write_sta[-- write_top] + 48);
    }
    int llen;
    inline int get_string (char c[], int &len = llen){
        len = 0;
        read_char = getchar ();
        while (read_char == ' ' || read_char == '\n' || read_char == '\r')
            read_char = getchar ();
        while (read_char != ' ' && read_char != '\n' && read_char != '\r'){
            c[++ len] = read_char;
            read_char = getchar ();
        }
        return len;
    }
}

const int N = 1e5, V = 50, mod = 1e9 + 7;
const unsigned long long sed = 37;
int n, ia, ct[V + 5], ans, jc[N + 5], inv[N + 5], inj[N + 5], sum;

vector < int > ac;
unordered_map < unsigned long long , int > mp;

inline unsigned long long Upload (vector < int > &a){
    unsigned long long res = 0;
    for (int i = V;i >= 1;-- i)
        res = res * sed + a[i];
    return res;
}

inline int Solve (int rest, int sum){
    if (rest == 0)
        return 1;
    if (sum >= V)
        return jc[rest];
    unsigned long long Hash = Upload (ac);
    if (mp.count (Hash))
        return mp[Hash];
    for (int i = 1;i <= sum;++ i)
        if (ac[i] < ct[i]){
            ++ ac[i];
            mp[Hash] += Solve (rest - 1, sum + i) * (ct[i] - ac[i] + 1) % mod;
            -- ac[i];
        }
    mp[Hash] %= mod;
    return mp[Hash];
}

signed main (){
    io::read (n), io::read (ia);
    sum += ia;
    for (int i = 1, a;i <= n;++ i){
        ++ ct[io::read (a)];
        sum += a;
    }
    inv[1] = jc[0] = jc[1] = inj[0] = inj[1] = 1;
    for (int i = 2;i <= n;++ i){
        inv[i] = 1ll * inv[i - mod % i] * (mod / i + 1) % mod;
        inj[i] = 1ll * inj[i - 1] * inv[i] % mod;
        jc[i] = 1ll * jc[i - 1] * i % mod;
    }
    ac.resize (V + 1, 0);
    io::write (1ll * Solve (n - ct[0], ia) * jc[n] % mod * inj[n - ct[0]] % mod), puts ("");
    return 0;
}