/**
 * @file qoj3998F1.cpp
 * @author n685
 * @brief
 * @date 2023-07-19
 *
 *
 */
#include <bits/stdc++.h>

#ifdef LOCAL
std::ifstream cin;
std::ofstream cout;
using std::cerr;
#else
using std::cin;
using std::cout;
#define cerr                                                                   \
  if (false)                                                                   \
  std::cerr
#endif

namespace K {
int64_t mx;

int64_t sz = 1;
std::vector<std::vector<int64_t>> val;
void rollback(int a) { sz -= a; }
void add(int64_t v, int64_t c) {
  sz++;
  auto &pre = val[sz - 2];
  auto &cur = val[sz - 1];
  int64_t ans = 0;
  for (int64_t i = 0; i <= mx; ++i) {
    cur[i] = pre[i];
    if (i >= c)
      cur[i] = std::max(cur[i], pre[i - c] + v);
    ans += cur[i];
  }
  cur.back() = ans;
}
int64_t sum() { return val[sz - 1].back(); }
}; // namespace K

int main() {
#ifdef LOCAL
  cin.open("input.txt");
  cout.rdbuf()->pubsetbuf(0, 0);
  cout.open("output.txt");
#else
  cin.tie(nullptr)->sync_with_stdio(false);
#endif

  int n;
  int64_t k, E;

  cin >> n >> k >> E;
  K::mx = k;
  // K::val.push_back(std::vector<int64_t>(k + 2));
  K::val.resize(n + 1);
  for (int i = 0; i <= n; ++i)
    K::val[i].resize(k + 2);
  K::sz = 1;
  E *= k;

  std::vector<int64_t> v(n), a(n), b(n);
  for (int i = 0; i < n; ++i)
    cin >> v[i] >> a[i] >> b[i];

  int64_t ans = 0;
  auto dnq = [&](auto &self, int l, int r, int dl, int dr) {
    if (dl == dr) {
      if (dl == n - 1) {
        int dm = dl;
        for (int i = std::max(r + 1, dl); i <= dr; ++i) {
          if (i > dm)
            K::add(v[i], a[i]);
          else
            K::add(v[i], b[i]);
        }

        int ll = l, rr = std::min(r, dm);
        for (int i = dm + 1; i <= r; ++i)
          K::add(v[i], a[i]);
        while (ll < rr) {
          int mid = (ll + rr + 1) / 2;
          // add from mid to rr
          for (int i = ll; i < mid; ++i)
            K::add(v[i], a[i]);
          for (int i = mid; i <= rr; ++i)
            K::add(v[i], b[i]);
          if (K::sum() <= E) {
            K::rollback(rr - mid + 1);
            ll = mid;
          } else {
            K::rollback(rr - ll + 1);
            for (int i = mid; i <= rr; ++i)
              K::add(v[i], b[i]);
            rr = mid - 1;
          }
        }

        int m = ll;
        K::add(v[m], b[m]);
        bool g = (K::sum() <= E);
        // added all but m
        K::rollback(std::min(r, dm) - l + dr - std::max(r + 1, dl) +
                    std::max(0, r - dm) + 2);
        if (g)
          ans += (int64_t)(ll - l + 1) * (n - dl);
      } else
        ans += (int64_t)(r - l + 1) * (n - dl);
      return;
    }
    int dm = (dl + dr) / 2;
    for (int i = std::max(r + 1, dl); i <= dr; ++i) {
      if (i > dm)
        K::add(v[i], a[i]);
      else
        K::add(v[i], b[i]);
    }

    int ll = l, rr = std::min(r, dm);
    for (int i = dm + 1; i <= r; ++i)
      K::add(v[i], a[i]);
    while (ll < rr) {
      int mid = (ll + rr + 1) / 2;
      // add from mid to rr
      for (int i = ll; i < mid; ++i)
        K::add(v[i], a[i]);
      for (int i = mid; i <= rr; ++i)
        K::add(v[i], b[i]);
      if (K::sum() <= E) {
        K::rollback(rr - mid + 1);
        ll = mid;
      } else {
        K::rollback(rr - ll + 1);
        for (int i = mid; i <= rr; ++i)
          K::add(v[i], b[i]);
        rr = mid - 1;
      }
    }

    int m = ll;
    K::add(v[m], b[m]);
    bool g = (K::sum() <= E);
    // added all but m
    K::rollback(std::min(r, dm) - l + dr - std::max(r + 1, dl) +
                std::max(0, r - dm) + 2);
    if (!g)
      m = l - 1;

    if (g) {
      for (int i = m + 1; i < std::min(r + 1, dl); ++i)
        K::add(v[i], b[i]);
      for (int i = std::max(m + 1, dm + 1); i <= dr; ++i)
        K::add(v[i], a[i]);
      self(self, l, m, dl, dm);
      K::rollback(std::max(0, std::min(r + 1, dl) - m - 1) + dr -
                  std::max(m, dm));
    }

    if (m + 1 <= r) {
      for (int i = l; i <= std::min(dm, m); ++i)
        K::add(v[i], a[i]);
      for (int i = std::max(r + 1, dl); i <= dm; ++i)
        K::add(v[i], b[i]);
      self(self, m + 1, r, dm + 1, dr);
      K::rollback(dm - std::max(r + 1, dl) +
                  std::max(0, std::min(dm, m) - l + 1) + 1);
    }
  };
  dnq(dnq, 0, n - 1, 0, n - 1);

  cout << ans << '\n';
}