#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

inline bool inside(const pair<int, int> &x, const pair<int, int> &y) {
  return (x.first <= y.first && y.second <= x.second);
}

inline bool intersect(const pair<int, int> &x, const pair<int, int> &y) {
  return !(x.second < y.first || y.second < x.first);
}

inline void merge(vector<pair<int, int>> &x, vector<pair<int, int>> &y, int add = 1) {
  if (x.empty()) {
    for (auto it : y)
      x.push_back({it.first + add, it.second + add});
  } else {
    for (auto interval : y) {
      auto to_merge = make_pair(interval.first + add, interval.second + add);
      auto wh = x.begin();
      int bad = 0, found = 0;
      for (auto it = x.begin(); !x.empty() && it != x.end();) {
        if (inside(*it, to_merge)) {
          bad = true;
          break;
        }

        if (intersect(*it, to_merge)) {
          if (!found) {
            it->first = min(to_merge.first, it->first);
            it->second = max(to_merge.second, it->second);
            to_merge = *it;
            found = true;
            wh = it;
            it = next(it);
          } else {
            wh->first = min(it->first, wh->first);
            wh->second = max(it->second, wh->second);
            to_merge = *wh;
            auto tmp = next(it);
            x.erase(it);
            it = tmp;
          }
        } else {
          it = next(it);
        }
      }

      if (!bad && !found)
        x.push_back(to_merge);
    }
  }
}

const int DIM = 2e5 + 5;
vector<pair<int, int>> arb[4 * DIM];
void build(int st, int dr, int nod, vector<vector<pair<int, int>>> &dp) {
  if (st == dr) {
    arb[nod] = dp[st];
    return;
  }

  int mij = (st + dr) / 2;
  build(st, mij, nod * 2, dp);
  build(mij + 1, dr, nod * 2 + 1, dp);

  arb[nod] = arb[nod * 2];
  merge(arb[nod], arb[nod * 2 + 1], mij - st + 1);
}

void query(int x, int y, int st, int dr, int nod, vector<pair<int, int>> &ans, int &add) {
  if (x <= st && dr <= y) {
    merge(ans, arb[nod], add);
    add += (dr - st + 1);
    return;
  }

  int mij = (st + dr) / 2;
  if (x <= mij)
    query(x, y, st, mij, nod * 2, ans, add);

  if (y >= mij + 1)
    query(x, y, mij + 1, dr, nod * 2 + 1, ans, add);
}

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

  int n, s;
  cin >> n >> s;
  vector<int> cnt(s + 1, 0);
  vector<int> a(n + 1, 0);
  int cnt_neg = 0, new_s = 0;
  for (int i = 1; i <= n; ++i) {
    cin >> a[i];
    a[i] -= 1;
    if (a[i] >= 0) {
      ++cnt[a[i]];
      new_s += a[i];
    }
    else
      ++cnt_neg;
  }

  s = new_s;
  vector<vector<pair<int, int>>> dp(s + 1);
  int sx = 0;
  for (int val = 0; val <= s; ++val) {
    if (!cnt[val])
      continue;

    if (val == 0) {
      dp[0].push_back({0, cnt[val]});
      continue;
    }

    int last = sx;
    sx += val * cnt[val];
    for (int j = sx; j >= val; --j) {
      int x = val, nr = 1;
      if (j > last) {
        int dif = j - last;
        nr = (dif + nr - 1) / val;
        x = val * nr;
      }

      for (; x <= j && nr <= cnt[val]; x += val, ++nr)
        merge(dp[j], dp[j - x], nr);
    }
  }

  ll ans = 0;
  build(1, s, 1, dp);

  for (int i = 1; i <= cnt_neg; ++i) {
    vector<pair<int, int>> tmp = dp[0];

    if (i < cnt_neg) {
      int add = 1;
      query(1, cnt_neg - i, 1, s, 1, tmp, add);
    }

    for (auto interval : tmp)
      ans += interval.second - interval.first + 1;
  }

  for (int i = 0; i <= s; ++i) {
    if (i < s && cnt_neg > 0) {
      int add = 1;
      query(i + 1, min(i + cnt_neg, s), 1, s, 1, dp[i], add);
    }

    for (auto interval : dp[i])
      ans += interval.second - interval.first + 1;
  }

  
  cout << ans << endl;
  return 0;
}