#include <bits/stdc++.h>
using namespace std;

typedef int64_t ll;

template<typename T1, typename T2> inline bool umn (T1& a, T2 b) {if (b < a) {a = b; return 1;} return 0;}

const int N = 300;
const int T = 300;

struct Input {
    int n, t;
    ll k;
    ll a[N + 1], b[N + 1], c[N + 1];

    bool read () {
        if (!(cin >> n >> t >> k)) {
            return 0;
        }
        forn (i, n) {
            scanf("%" SCNd64 "%" SCNd64 "%" SCNd64, &a[i], &b[i], &c[i]);
        }
        return 1;
    }

    void init (const Input &input) {
        *this = input;
    }
};

struct Data: Input {
    ll ans;

    void write () {
        cout << ans << endl;
    }
};


namespace Main {

    const ll inf = ll(1e18);

    struct Solution: Data {

        ll sa[N + 2];
        ll sb[N + 2];

        ll d[N + 2][T + 1][2];
        ll g[T + 1][2];

        void solve () {
            a[n] = 0;
            b[n] = 0;
            c[n] = 0;
            sa[0] = 0;
            sb[0] = 0;
            forn (i, n + 1) {
                sa[i + 1] = sa[i] + a[i];
                sb[i + 1] = sb[i] + b[i];
            }
            memset(d[0], 0, sizeof d[0]);
            forn (i, n + 1) {
                forn (j, t + 1) {
                    forn (z, 2) {
                        d[i + 1][j][z] = inf;
                        g[j][z] = inf;
                    }
                }
                d[i + 1][0][0] = 0;
                d[i + 1][0][1] = 0;
                forn (j, t + 1) {
                    forn (z, 2) {
                        if (d[i][j][z] == inf || (z ? 0 : a[i]) + j * b[i] > c[i]) {
                            continue;
                        }
                        umn(d[i + 1][j][z], d[i][j][z]);
                        umn(g[j][z], ((z ? 0 : sa[i]) + j * sb[i] + k - 1) / k);
                    }
                }
                forn (s, t + 1) {
                    forn (z, 2) {
                        if (g[s][z] == inf) {
                            continue;
                        }
                        ll val = (z ? 0 : sa[i + 1]) + s * sb[i + 1] - k * g[s][z];
                        if (i == n) {
                            val = 0;
                        }
                        if (val < 0) {
                            continue;
                        }
                        forn (j, t - s + 1) {
                            if (d[i][j][1] == inf || val % k + j * b[i] > c[i]) {
                                continue;
                            }
                            ll add = (max<ll>(val + j * b[i] - c[i], 0) + k - 1) / k;
                            umn(d[i + 1][s + j][z], g[s][z] + add + d[i][j][1]);
                            umn(g[s + j][z], g[s][z] + add + (j * sb[i] + k - 1) / k);
                        }
                    }
                }
            }
            ans = d[n + 1][t][0];
        }

        void clear () {
            *this = Solution();
        }
    };
}


Main::Solution sol;

int main () {
    cout.setf(ios::showpoint | ios::fixed);
    cout.precision(20);

    sol.read();
    sol.solve();
    sol.write();

    return 0;
}