#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
inline bool chmax(A& a, B b) {
  return b > a ? a = b, 1 : 0;
}
template <class A, class B>
inline bool chmin(A& a, B b) {
  return b < a ? a = b, 1 : 0;
}
template <class T>
using MaxHeap = priority_queue<T, vector<T>, greater<T> >;
using ll = long long;
using pii = pair<int, int>;
using byte = unsigned char;
inline bool inside(int x, int y, int W, int H) {
  return x >= 0 && y >= 0 && x < W && y < H;
}
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr int dx[] = {1, 0, -1, 0};
constexpr int dy[] = {0, 1, 0, -1};
struct Point : public pii {
  int &x = this->first, &y = this->second;
  explicit Point(int x = 0, int y = 0) : pii(x, y) {}
};
struct Writer {
  static constexpr size_t BUFF_SIZE = 1 << 18;
  static char _buf[BUFF_SIZE];
  explicit Writer() { setvbuf(stdout, _buf, _IOFBF, sizeof(_buf)); }
  inline void ln() { putchar('\n'); }
  inline Writer& operator()(int n) {
    printf("%d", n);
    return *this;
  }
  inline Writer& operator()(ll n) {
    printf("%lld", n);
    return *this;
  }
  inline Writer& operator()(char c) {
    printf("%c", c);
    return *this;
  }
  inline Writer& operator()(double d) {
    printf("%lf", d);
    return *this;
  }
  inline Writer& operator()(const char* s) {
    printf("%s", s);
    return *this;
  }
  inline Writer& operator()(const string& s) {
    printf("%s", s.c_str());
    return *this;
  }
  inline Writer& operator()(bool f) {
    printf("%s", f ? "true" : "false");
    return *this;
  }
  inline Writer& operator()(void) {
    putchar('\n');
    return *this;
  }
  template <class InputIterator>
  inline Writer& operator()(InputIterator first, InputIterator last,
                            const char* space = " ") {
    for (; first != last; ++first) {
      (*this)(*first);
      printf("%s", (first + 1 == last) ? "\n" : space);
    }
    return *this;
  }
};
char Writer::_buf[BUFF_SIZE];
template <class T>
inline Writer& operator<(Writer& o, const T& v) {
  return o(v);
}
struct Scanner {
  char tmp[65536];
  inline Scanner& read(int& n) {
    scanf("%d", &n);
    return *this;
  }
  inline Scanner& read(ll& n) {
    scanf("%lld", &n);
    return *this;
  }
  inline Scanner& read(char& c) {
    scanf(" %c", &c);
    return *this;
  }
  inline Scanner& read(double& d) {
    scanf("%lf", &d);
    return *this;
  }
  inline Scanner& read(char* s) {
    scanf("%s", s);
    return *this;
  }
  inline Scanner& read(string& s) {
    scanf("%s", tmp);
    s = string(tmp);
    return *this;
  }
};
template <class T>
inline Scanner& operator>(Scanner& in, T& v) {
  return in.read(v);
}
template <class T>
inline Scanner& operator,(Scanner& in, T& v) {
  return in.read(v);
}
Writer out;
Scanner in;
namespace ydk {
constexpr int LIM = (int)1e5 * 2;
int N, x;
ll a[105];
map<ll, int> dp[105];
int slv(int i, ll rem) {
  if (i == N) return rem == 0 ? 0 : -1;
  if (dp[i].count(rem)) return dp[i][rem];
  int ret = 0;
  if (rem >= a[i]) {
    ret = slv(i + 1, rem - a[i]) + 1;
  }
  chmax(ret, slv(i + 1, rem));
  return dp[i][rem] = ret;
}
signed main(void) {
  in > N, x;
  for (int i = 0; i < (int)(N); ++i) {
    in > a[i];
  }
  out < (max(slv(0, x), 0)) < '\n';
  return 0;
}
}  // namespace ydk
signed main(void) { return ydk::main(); }
