#include<bits/stdc++.h>
#include<atcoder/all>
namespace my{
using namespace std;
#define done(...) return pp(__VA_ARGS__)
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define VRD(T,n,...) vec<T>__VA_ARGS__;setsize({n},__VA_ARGS__);lin(__VA_ARGS__)
#define FO(n) for(ll ij=n;ij--;)
#define FOR(i,...) for(auto[i,i##stop,i##step]=range(0,__VA_ARGS__);i<i##stop;i+=i##step)
#define fo(i,...) FO##__VA_OPT__(R)(i __VA_OPT__(,__VA_ARGS__))
#define of(i,...) for(auto[i,i##stop,i##step]=range(1,__VA_ARGS__);i>=i##stop;i-=i##step)
#define fe(a,i,...) for(auto&&__VA_OPT__([)i __VA_OPT__(,__VA_ARGS__]):a)
#define single_testcase void solve();}int main(){my::io();my::solve();}namespace my{
void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<<fixed<<setprecision(15);}
using ll=long long;
template<class...A>auto range(bool s,A...a){array<ll,3>r{0,0,1};ll I=0;((r[I++]=a),...);if(!s&&I==1)swap(r[0],r[1]);r[0]-=s;return r;}
constexpr char nl=10;
constexpr char sp=32;
constexpr ll log2_floor(auto x){ll r=0;while(x>1)x>>=1,++r;return r;}
auto ceil(auto x,auto y){if(y<0)x=-x,y=-y;return x<=0?x/y:(x-1)/y+1;}
auto min(const auto&...a){return min(initializer_list<common_type_t<decltype(a)...>>{a...});}

template<class A,class B>struct pair{
  A a;B b;
  pair()=default;
  pair(A a,B b):a(a),b(b){}
  pair(const std::pair<A,B>&p):a(p.first),b(p.second){}
  auto operator<=>(const pair&)const=default;
  friend ostream&operator<<(ostream&o,const pair&p){return o<<p.a<<sp<<p.b;}
};

template<class T,class U>ostream&operator<<(ostream&o,const std::pair<T,U>&p){return o<<p.first<<sp<<p.second;}

template<class V>concept vectorial=is_base_of_v<vector<typename V::value_type>,V>;
template<class T>struct vec_attr{using core_type=T;static constexpr int d=0;};
template<vectorial V>struct vec_attr<V>{using core_type=typename vec_attr<typename V::value_type>::core_type;static constexpr int d=vec_attr<typename V::value_type>::d+1;};
template<class T>using core_t=vec_attr<T>::core_type;
template<class V>istream&operator>>(istream&i,vector<V>&v){fe(v,e)i>>e;return i;}
template<class V>ostream&operator<<(ostream&o,const vector<V>&v){fe(v,e)o<<e<<string(&e!=&v.back(),vectorial<V>?nl:sp);return o;}

template<class V>struct vec:vector<V>{
  using vector<V>::vector;
  vec(const vector<V>&v){vector<V>::operator=(v);}

  vec&operator^=(const vec&u){this->insert(this->end(),u.begin(),u.end());return*this;}
  vec operator^(const vec&u)const{return vec{*this}^=u;}
  vec&operator++(){fe(*this,e)++e;return*this;}
  vec&operator--(){fe(*this,e)--e;return*this;}

  auto scan(const auto&f)const{pair<core_t<V>,bool>r{};fe(*this,e)if constexpr(!vectorial<V>)r.b?f(r.a,e),r:r={e,1};else if(auto s=e.scan(f);s.b)r.b?f(r.a,s.a),r:r=s;return r;}
  auto min()const{return scan([](auto&a,const auto&b){a>b?a=b:0;;}).a;}
};
template<class T=ll,size_t n,size_t i=0>auto make_vec(const ll(&s)[n],T x={}){if constexpr(n==i+1)return vec<T>(s[i],x);else{auto X=make_vec<T,n,i+1>(s,x);return vec<decltype(X)>(s[i],X);}}
template<ll n,class...A>void setsize(const ll(&l)[n],A&...a){((a= make_vec(l,core_t<A>())),...);}

void lin(auto&...a){(cin>>...>>a);}
template<char c=sp>void pp(const auto&...a){ll n=sizeof...(a);((cout<<a<<string(--n>0,c)),...);cout<<nl;}

uint64_t kth_root_floor(uint64_t a,ll k){
  if (k==1)return a;
  auto within=[&](uint32_t x){uint64_t t=1;fo(k)if(__builtin_mul_overflow(t,x,&t))return false;return t<=a;};

  uint64_t r=0;
  of(i,sizeof(uint32_t)*CHAR_BIT)if(within(r|(1u<<i)))r|=1u<<i;
  return r;
}
auto sqrt_floor(auto x){return kth_root_floor(x,2);}

struct bitvec{
  using u64=uint64_t;
  static constexpr size_t block_size=sizeof(u64)*CHAR_BIT;
  static constexpr size_t block_size_exponent=log2_floor(block_size);
  static constexpr size_t block_index(size_t i){return i>>block_size_exponent;}
  static constexpr size_t bit_index(size_t i){return i&(block_size-1);}

  size_t n;
  vec<u64>bits;
  size_t size()const{return n;}

  bitvec(size_t n):n(n),bits(ceil(n,block_size)){}
  bitvec(const string&s):n(s.size()),bits(ceil(s.size(),block_size)){fo(i,n)bits[block_index(i)]|=u64(s[i]-'0')<<bit_index(i);}
  bitvec&operator=(u64 x){vec<u64>{x}.swap(bits);return*this;}

  struct proxy{
    decltype(bits)&bits_proxy;
    size_t I;
    proxy(decltype(bits)&bits_proxy,size_t I):bits_proxy(bits_proxy),I(I){}
    auto&operator=(bool f){
      bits_proxy[block_index(I)]&=~(u64(1)<<bit_index(I));
      bits_proxy[block_index(I)]|=u64(f)<<bit_index(I);
      return*this;
    }
    template<integral X>auto&operator=(X x){return this->operator=(static_cast<bool>(x&1));}
    auto&operator=(const proxy&p){return this->operator=(static_cast<bool>(p));}
    operator bool()const{return bits_proxy[block_index(I)]>>bit_index(I)&1;}
  };

  decltype(auto)operator[](size_t i){return proxy{bits,i};}
  decltype(auto)operator[](size_t i)const{return bits[block_index(i)]>>bit_index(i)&1;}

  auto&operator&=(const bitvec&b){fo(i,bits.size())bits[i]&=b.bits[i];return*this;}
  auto&operator|=(const bitvec&b){fo(i,bits.size())bits[i]|=b.bits[i];return*this;}
  auto&operator^=(const bitvec&b){fo(i,bits.size())bits[i]^=b.bits[i];return*this;}

  auto&operator<<=(int k){
    int q=k/block_size,r=k-q*block_size;
    if(r==0){
      of(i,bits.size(),q)bits[i]=bits[i-q];
      fo(i,q)bits[i]=0;
    }else{
      of(i,bits.size(),q+1)bits[i]=bits[i-q]<<r|bits[i-q-1]>>(block_size-r);
      bits[q]=(bits[0]<<r);
      fo(i,q)bits[i]=0;
    }
    return*this;
  }
  auto&operator>>=(int k){
    int q=k/block_size,r=k-q*block_size;
    if(r==0){
      fo(i,bits.size()-q)bits[i]=bits[i+q];
      fo(i,bits.size()-q,bits.size())bits[i]=0;
    }else{
      fo(i,bits.size()-q-1)bits[i]=bits[i+q]>>r|bits[i+q+1]<<(block_size-r);
      bits[bits.size()-q-1]=bits[bits.size()-1]>>r;
      fo(i,bits.size()-q,bits.size())bits[i]=0;
    }
    return*this;
  }

  auto operator&(const bitvec&b)const{return bitvec{*this}&=b;}
  auto operator|(const bitvec&b)const{return bitvec{*this}|=b;}
  auto operator^(const bitvec&b)const{return bitvec{*this}^=b;}
  auto operator<<(int k)const{return bitvec{*this}<<=k;}
  auto operator>>(int k)const{return bitvec{*this}>>=k;}

  ll count()const{ll r=0;fe(bits,e)r+=std::popcount(e);return r;}

  string to_string()const{string s{};fo(i,size())s+=(*this)[i]+'0';return s;}
  friend istream&operator>>(istream&i,bitvec&b){string s;i>>s;b=s;return i;}
  friend ostream&operator<<(ostream&o,const bitvec&b){return o<<b.to_string();}
};

single_testcase
void solve(){
  LL(N,K);
  VRD(int,N,a);

  ll block_size=sqrt_floor(N);
  ll block_num=ceil(N,block_size);
  vec<bitvec>mem(block_num,bitvec(K+1));

  bitvec cu(K+1);
  cu[0]=1;
  fo(i,N){
    if(i%block_size==0)mem[i/block_size]=cu;
    cu|=cu<<a[i];
  }
  if(cu[K]==0)done(-1);

  vec<bitvec>dp(block_size,bitvec(K+1));

  ll ans=0;
  cu=bitvec(K+1);
  cu[K]=1;
  of(i,block_num){
    ll L=min(block_size,N-i*block_size);
    dp[0]=mem[i];
    fo(j,L-1)dp[j+1]=dp[j]<<a[i*block_size+j]|dp[j];

    of(j,L){
      if((dp[j]&cu).count()==0)++ans;
      cu|=cu>>a[i*block_size+j];
    }
  }
  pp(ans);
}}