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

#include<atcoder/modint>
#include<atcoder/convolution>
using mint = atcoder::modint;

vector<mint> conv(vector<mint>a,vector<mint>b){
    int n = a.size();
    int m = b.size();
    vector<mint> res(n+m-1,0);
    for(int i = 0;i<n;i++) for(int j = 0;j<m;j++) res[i+j] += a[i] * b[j];
    return res;
}
ostream& operator<<(ostream& os, const mint& m){
    os << m.val();
    return os;
}

template < typename mint >
struct FPS:vector<mint>{
    FPS(){}
    FPS(int n){
        this->resize(n);
    }
    FPS(vector<mint>a){
        *this = a;
    }
    FPS &operator+=(const FPS&r){
        if(r.size()>this->size()) this->resize(r.size());
        for(int i = 0;i<(int)r.size();i++) (*this)[i] += r[i];
        return *this;
    }
    FPS &operator+=(const mint&r){
        if(this->empty()) this->resize(1);
        (*this)[0] += r;
        return *this;
    }
    FPS &operator-=(const FPS&r){
        if(r.size()>this->size()) this->resize(r.size());
        for(int i = 0;i<(int)r.size();i++) (*this)[i] -= r[i];
        return *this;
    }
    FPS &operator-=(const mint&r){
        if(this->empty()) this->resize(1);
        (*this)[0] -= r;
        return *this;
    }
    FPS &operator*=(const FPS&r){
        vector<mint> nxt = conv(*this,r);
        this->resize(nxt.size());
        for(int i = 0;i<nxt.size();i++) (*this)[i] = nxt[i];
        return *this;
    }
    FPS &operator*=(const mint&r){
        for(int i = 0;i<(int)this->size();i++) (*this)[i] *= r;
        return *this;
    }
    FPS operator+(const FPS&r) const {return FPS(*this)+=r;}
    FPS operator+(const mint&r) const {return FPS(*this)+=r;}
    FPS operator-(const FPS&r) const {return FPS(*this)-=r;}
    FPS operator-(const mint&r) const {return FPS(*this)-=r;}
    FPS operator*(const FPS&r) const {return FPS(*this)*=r;}

    void print(){
        for(int i = 0;i<(int)this->size();i++){
            if(i) cout<<" ";
            cout<<(*this)[i];
        }
        cout<<endl;
    }

    int deg(){return (int)this->size()-1;}

    // f^-1 mod x^n
    FPS<mint> inv(int n){
        assert((*this)[0].val()!=0);
        FPS<mint> g(1);
        g[0] = 1/(*this)[0];
        ll now = 1;
        FPS<mint> tmp(1);
        tmp[0] = 2;
        while(now<n){
            g = g * (tmp-g*(*this));
            now <<= 1;
            if(g.size()>now) g.resize(now);
        }
        g.resize(n);
        return g;
    }

    FPS<mint> diff(){
        FPS<mint>g(this->size()-1);
        for(int i = 0;i+1<this->size();i++) g[i] = mint(i+1) * (*this)[i+1];
        return g;
    }

    FPS<mint> integral(){
        FPS<mint>g(this->size()+1);
        g[0] = 0;
        for(int i = 1;i<=this->size();i++) g[i] = (*this)[i-1] / mint(i);
        return g;
    }

    FPS<mint> log(int n){
        assert((*this)[0].val()==1);
        return ((*this).diff() * (*this).inv(n-1)).integral();
    }

    FPS<mint> exp(int n){
        assert((*this)[0].val()==0);
        FPS<mint> g(1);
        g[0] = 1;
        ll now = 1;
        FPS<mint> tmp(1);
        tmp[0] = 1;
        while(now<n){
            g = g * ((*this) + tmp - g.log(now<<1));
            now <<= 1;
            if(g.size()>now) g.resize(now);
        }
        return g;
    }
    
};

template < typename mint >
FPS<mint> pow(FPS<mint>&a,ll k,int n){
    FPS<mint> ans(n+1);
    ans[0] += 1;
    FPS<mint> tmp = a;
    tmp.resize(n+1);
    while(k){
        if(k&1){
            ans *= tmp;
            ans.resize(n+1);
        }
        tmp *= tmp;
        tmp.resize(n+1);
        k>>=1;
    }
    return ans;
}
//[x^n] P(x)/Q(x)
template< typename mint >
mint Bostan_Mori(FPS<mint>&p,FPS<mint>&q,ll n){
    if(n==0) return p[0];
    int d = q.deg();
    assert(p.deg()<d);
    FPS<mint> qi = q;
    for(int i = 0;i<qi.size();i++) if(i%2==1) qi[i] *= -1;
    p *= qi;
    q *= qi;
    for(int i = 0;i*2<q.size();i++) q[i] = q[i*2];
    q.resize((int)(q.size()+1)/2);
    assert(q.deg()==d);
    if(n%2==0){
        for(int i = 0;i*2<p.size();i++) p[i] = p[i*2];
        p.resize((int)(p.size()+1)/2);
        return Bostan_Mori(p,q,n/2);
    }else{
        for(int i = 0;i*2+1<p.size();i++) p[i] = p[i*2+1];
        p.resize((int)p.size()/2);
        return Bostan_Mori(p,q,(n-1)/2);
    }
}
template < typename mint >
FPS<mint> all_mul(vector<FPS<mint>>&fs){
    while(true){
        int n = fs.size();
        if(n==1) break;
        int m = (n+1)/2;
        for(int i = 0;i<m;i++){
            if(2*i+1==n) fs[i] = fs[2*i];
            else fs[i] = fs[2*i] * fs[2*i+1];
        }
        fs.resize(m);
    }
    return fs[0];
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false); 

    mint::set_mod(1234567891);

    ll n,m;
    cin>>n>>m;
    vector<FPS<mint>> fs;
    for(int i = 0;i<n;i++){
        int a;
        cin>>a;
        FPS<mint> g(a+1);
        g[0] = 1;
        g[a] = -1;
        fs.push_back(g);
    }
    auto f = all_mul(fs);
    FPS<mint> g(1);
    g[0] = 1;
    cout<<Bostan_Mori(g,f,m)<<endl;
}