#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5;
using ll = long long;
#define int ll
vector<pair<int, int>> vp[N];
int n, m, k;
struct SegTree {
pair<int, int> aint[4 * N + 5];
int lazy[4 * N + 4];
int n;
SegTree(int _n) {
n = _n;
build(1, 1, n);
}
void propag(int x) {
aint[x].first += lazy[x];
if (2 * x + 1 < 4 * N + 5) {
lazy[2 * x] += lazy[x];
lazy[2 * x + 1] += lazy[x];
}
lazy[x] = 0;
}
void build(int pos, int st, int dr) {
aint[pos] = {0, st};
lazy[pos] = 0;
if (st == dr) {
return;
}
int mid = (st + dr) / 2;
build(2 * pos, st, mid);
build(2 * pos + 1, mid + 1, dr);
}
void update(int pos, int st, int dr, int l, int r, int val) {
propag(pos);
if (l <= st && dr <= r) {
lazy[pos] += val;
propag(pos);
return;
}
int mid = (st + dr) / 2;
if (l <= mid) {
update(2 * pos, st, mid, l, r, val);
} else {
propag(2 * pos);
}
if (mid < r) {
update(2 * pos + 1, mid + 1, dr, l, r, val);
} else {
propag(2 * pos + 1);
}
aint[pos] = min(aint[2 * pos], aint[2 * pos + 1]);
}
pair<int, int> query(int pos, int st, int dr, int l, int r) {
propag(pos);
if (l <= st && dr <= r) {
return aint[pos];
}
int mid = (st + dr) / 2;
if (r <= mid) {
return query(2 * pos, st, mid, l, r);
} else if (mid < l) {
return query(2 * pos + 1, mid + 1, dr, l, r);
} else {
return min(query(2 * pos, st, mid, l, r), query(2 * pos + 1, mid + 1, dr, l, r));
}
}
};
pair<int, int> greedy(int lambda) {
vector<pair<int, int>> dp(n + 1);
SegTree ds(n + 1);
for (int i = 1; i <= n; i ++) {
for (auto j : vp[i]) {
ds.update(1, 1, n + 1, 1, j.first, j.second);
}
auto x = ds.query(1, 1, n + 1, 1, i);
dp[i] = {x.first + lambda, dp[x.second - 1].second + 1};
ds.update(1, 1, n + 1, i + 1, i + 1, dp[i].first);
}
auto x = ds.query(1, 1, n + 1, 1, n + 1);
return {x.first, dp[x.second - 1].second};
}
signed main() {
cin >> n >> m >> k;
for (int i = 0; i < m; i ++) {
int s, t, c;
cin >> s >> t >> c;
vp[t].push_back({s, c});
}
int lambda = 0;
for (int pas = 1ll << 50; pas; pas >>= 1) {
if (greedy(lambda + pas).second >= k) {
lambda += pas;
}
}
cout << max(0ll, greedy(lambda).first - k * lambda) << '\n';
}
