#include <bits/stdc++.h>

using namespace std;

#define ll long long
#define flt double
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()

const ll inf = 1e18;
mt19937 rnd(234);

struct SGT_summ {
    int n;
    vector<ll> t;

    void build(int _n) {
        n = 1;
        while (n < _n) {
            n *= 2;
        }
        t.assign(n + n, 0);
    }

    void add(int i, ll x) {
        i += n;
        for (; i >= 1; i /= 2) {
            t[i] += x;
        }
    }

    ll get(int l, int r) {
        ll rs = 0;
        l += n;
        r += n + 1;
        while (l < r) {
            if (l & 1) {
                rs += t[l];
                l += 1;
            }
            if (r & 1) {
                r -= 1;
                rs += t[r];
            }
            l /= 2;
            r /= 2;
        }
        return rs;
    }
};

struct SGT_add_min {
    int n;
    vector<ll> t;
    vector<ll> d;

    void upd(int v) {
        t[v] = min(t[v + v], t[v + v + 1]);
    }

    void apply(int v, ll x) {
        t[v] += x;
        d[v] += x;
    }

    void push(int v) {
        apply(v + v, d[v]);
        apply(v + v + 1, d[v]);
        d[v] = 0;
    }

    void build(int _n) {
        n = 1;
        while (n < _n) {
            n *= 2;
        }
        t.assign(n + n, 0);
        d.assign(n + n, 0);
    }

    void add(int v, int tl, int tr, int l, int r, ll x) {
        if (tr < l || r < tl) {
            return;
        }
        if (l <= tl && tr <= r) {
            apply(v, x);
            return;
        }
        int tm = (tl + tr) / 2;
        push(v);
        add(v + v, tl, tm, l, r, x);
        add(v + v + 1, tm + 1, tr, l, r, x);
        upd(v);
    }

    void add(int l, int r, ll x) {
        add(1, 0, n - 1, l, r, x);
    }

    ll get(int v, int tl, int tr, ll l, ll r) {
        if (tr < l || r < tl) {
            return inf;
        }
        if (l <= tl && tr <= r) {
            return t[v];
        }
        int tm = (tl + tr) / 2;
        push(v);
        return min(get(v + v, tl, tm, l, r), get(v + v + 1, tm + 1, tr, l, r));
    }

    ll get(int l, int r) {
        return get(1, 0, n - 1, l, r);
    }
};

struct bbr {
    int l, r;
    ll a;
};

int n, m, k;
vector<bbr> b;

ll solve_k1() {
    auto a = b;
    sort(all(a), [&](const bbr &x, const bbr &y) {
        return x.r < y.r;
    });
    SGT_summ sgt;
    sgt.build(n);
    ll rs = 0;
    for (auto [l, r, ai] : a) {
        ll d = sgt.get(l, r);
        if (d >= ai) {
            continue;
        }
        sgt.add(r, ai - d);
        rs += ai - d;
    }
    return rs;
}

ll get_mx_a() {
    ll rs = 1;
    for (auto [l, r, a] : b) {
        rs = max(rs, a);
    }
    return rs;
}

ll solve_a1() {
    ll rs = 0;
    for (auto [l, r, a] : b) {
        rs += a;
    }
    vector<vector<bbr>> pl(n + 1), pr(n + 1);
    for (auto [l, r, a] : b) {
        pr[r + 1].push_back(bbr{l, r, a});
        pl[l].push_back(bbr{l, r, a});
    }
    vector<ll> dp(n + 1, inf);
    dp[0] = 0;
    SGT_add_min sgt;
    sgt.build(n + 4);
    ll not_usd = m;
    for (int i = 1; i <= n; i += 1) {
        dp[i] = min(dp[i], sgt.get(0, i - 1) + k);
        sgt.add(i, i, dp[i]);
        for (auto [l, r, a] : pr[i]) {
            sgt.add(0, l, 1);
        }
        for (auto [l, r, a] : pl[i - 1]) {
            not_usd -= 1;
        }
        rs = min(rs, dp[i] + not_usd);
    }
    return rs;
}

int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    cin >> n >> m >> k;
    b.resize(m);
    for (int i = 0; i < m; i += 1) {
        int l, r;
        ll a;
        cin >> l >> r >> a;
        --l;
        --r;
        b[i] = bbr{l, r, a};
    }
    ll rs = 0;
    if (k == 1) {
        rs = solve_k1();
    } else if (get_mx_a() == 1) {
        rs = solve_a1();
    }
    cout << rs << "\n";
    return 0;
}

/*
2 4 2
1 1 1
1 1 1
1 1 1
2 2 1

*/