#include <algorithm>
#include <iostream>
#include <vector>

using i64 = long long;
using i128 = __int128_t;
using u32 = unsigned int;
using u64 = unsigned long long;
using u128 = __uint128_t;

void set_io(std::string name)
{
#ifndef NO_FREOPEN
  freopen((name + ".in").c_str(), "r", stdin);
  freopen((name + ".out").c_str(), "w", stdout);
#endif
  std::cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
}

struct Seg
{
  int l, r;
  Seg() : l(0), r(0) {}
  Seg(int l, int r) : l(l), r(r) {}
  bool operator<(const Seg &s) const { return std::tie(l, r) < std::tie(s.l, s.r); }
};

struct Segs
{
  std::vector<Seg> segs;

  Segs() {}
  Segs(const std::vector<Seg> &segs) : segs(segs) {}

  Segs &operator+=(int x) 
  {
    for (auto &s : segs) {
      s.l += x;
      s.r += x;
    }
    return *this;
  }

  Segs &operator+=(const Segs &s)
  {
    int n = segs.size(), m = s.segs.size();

    std::vector<Seg> res;
    res.reserve(n + m);

    auto add = [&res](const Seg &s)
    {
      if (!res.empty() && res.back().r >= s.l) {
        res.back().r = std::max(res.back().r, s.r);
      } else {
        res.emplace_back(s);
      }
    };

    int p = 0, q = 0;
    while (p < n && q < m) {
      if (segs[p].l < s.segs[q].l) add(segs[p++]);
      else add(s.segs[q++]);
    }
    while (p < n) add(segs[p++]);
    while (q < m) add(s.segs[q++]);

    segs = std::move(res);

    return *this;
  }

  int count() const
  {
    int res = 0;
    for (auto [l, r] : segs) {
      res += r - l;
    }
    return res;
  }

  bool empty() const { return segs.empty(); }
};

int main()
{
  int n, S;
  std::cin >> n >> S;
  std::vector<int> cnt(S + 1);
  for (int i = 0; i < n; i++) {
    int x;
    std::cin >> x;
    cnt[x]++;
  }

  std::vector<Segs> f(S * 2 + 1);

  if (cnt[1] == 0) {
    f[S] = std::vector{Seg(0, 1)};
  } else {
    f[S] = std::vector{Seg(0, cnt[1] + 1)};
  }

  if (cnt[0] != 0) {
    int ci = cnt[0];
    auto update = [&](int t)
    {
      int it = -t;
      for (int k = -S; k <= S; k++) {
        if (f[k + S].empty()) continue;
        auto s = f[k + S];
        s += t;
        f[k + it + S] += s;
      }
    };
    for (int t = 1; t <= ci; t *= 2) {
      update(t);
      ci -= t;
    }
    if (ci) update(ci);
  }

  for (int i = 2; i <= S; i++) {
    if (cnt[i] == 0) continue;
    int ci = cnt[i];
    auto update = [&](int t)
    {
      int it = (i - 1) * t;
      for (int k = S; k >= -S; k--) {
        if (f[k + S].empty()) continue;
        auto s = f[k + S];
        s += t;
        f[k + it + S] += s;
      }
    };
    for (int t = 1; t <= ci; t *= 2) {
      update(t);
      ci -= t;
    }
    if (ci) update(ci);
  }

  i64 ans = 0;
  for (int i = -S; i <= S; i++) {
    ans += f[i + S].count();
  }

  std::cout << ans << std::endl;
}