#include <algorithm>
#include <iostream>
#include <map>
#include <ranges>
#include <string>
#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)
  {
    std::vector<Seg> res;
    std::merge(segs.begin(), segs.end(), s.segs.begin(), s.segs.end(), std::back_inserter(res));

    int p = 0;
    for (const auto &s : res) {
      if (p > 0 && res[p - 1].r >= s.l) {
        res[p - 1].r = std::max(res[p - 1].r, s.r);
      } else {
        res[p++] = s;
      }
    }
    res.erase(res.begin() + p, res.end());

    segs = res;
    return *this;
  }

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

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::map<int, Segs> f;

  f[0] = std::vector{Seg(0, 1)};

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

  for (int i = 1; i <= S; i++) {
    if (cnt[i] == 0) continue;
    int ci = cnt[i];
    auto update = [&](int t)
    {
      int it = (i - 1) * t;
      for (auto [k, s] : f | std::views::reverse) {
        s += t;
        f[k + it] += s;
      }
    };
    for (int t = 1; t <= ci; t *= 2) {
      update(t);
      ci -= t;
    }
    update(ci);
  }

  i64 ans = 0;
  for (const auto &[_, s] : f) {
    ans += s.count();
  }

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