#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 VL(n,...) vec<ll>__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;}

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;}

  void emplace_front(const V&x={}){this->emplace(this->begin(),x);}
};
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;}

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<<=(ll k){of(i,bits.size())bits[i]=(bits[i]<<k)|(i?bits[i-1]>>(block_size-k):0);return*this;}
  auto&operator>>=(ll k){fo(i,bits.size())bits[i]=(bits[i]>>k)|(i+1<bits.size()?bits[i+1]<<(block_size-k):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<<(ll k)const{return bitvec{*this}<<=k;}
  auto operator>>(ll 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);
  VL(N,a);
  a.emplace_front();

  vec<bitvec>dp(N+1,bitvec(K+1));
  dp[0][0]=1; // dp[i][j]:i個目まで使ってjを作れるか．
  fo(i,1,N+1)dp[i]=dp[i-1]<<a[i]|dp[i-1];

  if(dp[N][K]==0)done(-1);

  vec<bitvec>ep(N+2,bitvec(K+1)); // ep[i][K-j]:i個目まで使ってjを作れるか．後の処理のためK-jビット目にjを作れるかの判定を入れる
  ep[N+1][K]=1;
  of(i,N+1,1)ep[i]=ep[i+1]>>a[i]|ep[i+1];

  ll ans=0;
  fo(i,1,N+1)if((dp[i-1]&ep[i+1]).count()==0)ans++; // dp[i-1][j]&ep[i-1][j]が真ならj+(K-j)=KよりjとK-jでKを作れる．したがって(dp[i-1]&ep[i+1]).count()==0ならKを作れない．
  pp(ans);
}}