#include "fish.h"
#include <bits/stdc++.h>

using namespace std;

typedef int ll;

const long long INF = 1'000'000'000'000'000'000;

long long max_weights(ll n, ll m, vector<ll> x, vector<ll> y, vector<ll> w) {
	vector<vector<pair<ll, ll>>> all(n);
	for (ll i = 0; i < m; i++) {
		all[x[i]].emplace_back(y[i], w[i]);
	}
	for (ll i = 0; i < n; i++) {
		sort(all[i].begin(), all[i].end());
	}
	vector<vector<long long>> dp(all[0].size() + 1, vector<long long>(all[1].size() + 1, -INF));
	ll now0 = 0, now1 = 0;
	long long sum = 0;
	dp[0][0] = 0;
	while (now0 < all[0].size() || now1 < all[1].size()) {
		ll nxt = min((now0 == all[0].size() ? n : all[0][now0].first),
			(now1 == all[1].size() ? n : all[1][now1].first));
		if (now0 < all[0].size() && nxt == all[0][now0].first) {
			now0++;
		}
		if (now1 < all[1].size() && nxt == all[1][now1].first) {
			sum += all[1][now1].second;
			now1++;
		}
		dp[now0][now1] = sum;
	}
	all.push_back(vector<pair<ll, ll>>(0));
	for (ll i = 1; i < n; i++) {
		vector<vector<long long>> ndp(all[i].size() + 1, vector<long long>(all[i + 1].size() + 1, -INF));
		for (ll ct = 0; ct <= all[i].size(); ct++) {
			ll nowi = 0, nowip = 0, nowim = 0;
			long long nansmcp = 0, nanslcp = 0;
			vector<long long> prefmax(1, 0), suffmax(1, 0);
			ll add = 0;
			for (ll cp = 0; cp <= all[i - 1].size(); cp++) {
				prefmax.push_back(max(prefmax.back(), dp[cp][ct] + add));
				if (cp < all[i - 1].size()) {
					add -= all[i - 1][cp].second;
				}
			}
			for (ll cp = all[i - 1].size(); cp >= 0; cp--) {
				suffmax.push_back(max(suffmax.back(), dp[cp][ct]));
			}
			reverse(suffmax.begin(), suffmax.end());
			suffmax.pop_back();
			prefmax.erase(prefmax.begin());
			ndp[ct][0] = max(ndp[ct][0], suffmax[0]);
			while (nowi < all[i].size() || nowip < all[i + 1].size() || nowim < all[i - 1].size()) {
				ll nxt = min({(nowi == all[i].size() ? n : all[i][nowi].first),
					(nowip == all[i + 1].size() ? n : all[i + 1][nowip].first),
					(nowim == all[i - 1].size() ? n : all[i - 1][nowim].first)});
				if (nowi < all[i].size() && nxt == all[i][nowi].first) {
					if (nowi < ct) {
						nansmcp -= all[i][nowi].second;
						nanslcp -= all[i][nowi].second;
					}
					nowi++;
				}
				if (nowip < all[i + 1].size() && nxt == all[i + 1][nowip].first) {
					nansmcp += all[i + 1][nowip].second;
					nanslcp += all[i + 1][nowip].second;
					nowip++;
				}
				if (nowim < all[i - 1].size() && nxt == all[i - 1][nowim].first) {
					//if (nowim >= cp) {
					nansmcp += all[i - 1][nowim].second;
					nowim++;
				}
				ndp[max(nowi, ct)][nowip] = max(ndp[max(nowi, ct)][nowip], nanslcp + suffmax[nowim]);
				ndp[max(nowi, ct)][nowip] = max(ndp[max(nowi, ct)][nowip], nansmcp + prefmax[nowim]);
			}
		}
		dp = ndp;
	}
	long long ans = 0;
	for (auto i : dp) {
		for (auto j : i) {
			ans = max(ans, j);
		}
	}
	return ans;
}

#ifdef LOCAL
int main() {
  int N, M;
  assert(2 == scanf("%d %d", &N, &M));

  std::vector<int> X(M), Y(M), W(M);
  for (int i = 0; i < M; ++i) {
    assert(3 == scanf("%d %d %d", &X[i], &Y[i], &W[i]));
  }

  long long result = max_weights(N, M, X, Y, W);
  printf("%lld\n", result);
  return 0;
}
#endif