Shared code

//#include<bits/stdc++.h>

#ifndef _GLIBCXX_NO_ASSERT
//#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cwchar>
#include <cwctype>

#if __cplusplus >= 201103L
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
//#include <cstdalign>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
//#include <cuchar>
#endif

// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>

#if __cplusplus >= 201103L
#include <array>
#include <atomic>
#include <chrono>
#include <codecvt>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif

#if __cplusplus >= 201402L
#include <shared_mutex>
#endif

#if __cplusplus >= 201703L
#include <any>
#include <charconv>
// #include <execution>
#include <filesystem>
#include <optional>
#include <memory_resource>
#include <string_view>
#include <variant>
#endif

#if __cplusplus > 201703L
#include <bit>
// #include <compare>
// #include <span>
// #include <syncstream>
#include <version>
#endif

using namespace std;

/*#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;

typedef tree<long long, null_type, less<long long>, rb_tree_tag,
         tree_order_statistics_node_update>
is;*/

#define fb find_by_order
#define ok order_of_key

#define mem(x,y) memset(x,y,sizeof x)

typedef int ll;
//typedef int ii;

typedef pair<ll,ll> pi;
typedef vector<pi> vii;

#define map unordered_map

#define INF 1000000007
#define pi 3.141592654

#define T while(t--)
#define for2(i,a,b) for(i=a;i>=b;i--)
#define for3(i,a,b) for(i=a;i<=b;i=i+2)
#define for1(i,a,b) for(i=a;i<=b;i=i+1)
#define for4(i,a,b) for(i=a;i>=b;i=i-2)

#define pb push_back
#define pf push_front
#define mp make_pair

#define ff first
#define ss second

#define si set<ll>
#define se multiset<ll>

typedef long double ld;
typedef vector<ll> vi;

#define all(v) sort(v.begin(),v.end())
#define all1(v) sort(v.rbegin(),v.rend())

#define pff(uuv) printf("%lld\n",uuv)

#define pf1(uu) printf("%.20Lf\n",uu)

bool comp(pair<ll,char> aa, pair<ll,char> bb) {
   if (aa.ff != bb.ff) return aa.ff > bb.ff;
   return aa.ss < bb.ss;
}
bool comp1(pair<ll,char> aa, pair<ll,char> bb) {
   if (aa.ff != bb.ff) return aa.ff < bb.ff;
   return aa.ss > bb.ss;
}
bool comp2(pair<ll,ll> aa, pair<ll,ll> bb) {
   if (aa.ff != bb.ff) return aa.ff > bb.ff;
   return aa.ss < bb.ss;
}
bool comp3(pair<ll,ll> aa, pair<ll,ll> bb) {
   if (aa.ff != bb.ff) return aa.ff < bb.ff;
   return aa.ss > bb.ss;
}

ll rup(ll ik,ll ikk){

if(ik%ikk==0) return ik/ikk;
else return (ik/ikk)+1;

}
ll gcd(ll a,ll b){
if(b==0) return a;

return gcd(b,a%b);


}
ll lcm(ll a ,ll b){

return (a*b)/gcd(a,b);


}

ll modpow(ll x, ll n, ll m) {
      if (n == 0) return 1%m;
      long long u = modpow(x,n/2,m);
      u = (u*u)%m;
      if (n%2 == 1) u = (u*x)%m;
      return u;
  
}

ll nm(ll a,ll b){


  return (b + (a%b)) % b;

}

struct hp {
   template <class T1, class T2>
   size_t operator()(const pair<T1, T2>& p) const
   {
       auto hash1 = hash<T1>{}(p.first);
       auto hash2 = hash<T2>{}(p.second);
       return hash1 ^ hash2;
   }
};

ll dp[1000001][100];

ll n,x,yy;
ll i,j;

vi v;

int main(){

   ios::sync_with_stdio(0);
   cin.tie(0);
   cout.tie(0);
   
   ll t=1;
   
   //cin>>t;
   
   while(t--){
     
       cin>>n>>x;
       
       for1(i,1,n){
       
           cin>>yy;
           v.pb(yy);
           
           dp[0][i-1]=1;
           
       }
       
       for1(i,1,x){
       
           for1(j,0,n-1){
           
               dp[i][j]=0;
               
               if(i-v[j]>=0){
                   
                   dp[i][j]+=dp[i-v[j]][j];
                   dp[i][j]%=INF;
                   
               }
               
               if(j-1>=0){
               
                   dp[i][j]+=dp[i][j-1];
                   dp[i][j]%=INF;
                   
               }
                   
               
           }
               
           
       }
           
       cout<<dp[x][n-1]<<"\n";
       
   }
 
     

}