#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<long long> dpp(all[1].size() + 1, -INF);
	vector<long long> dpnp(all[1].size() + 1, -INF);
	vector<ll> to(all[1].size() + 1, -1);
	ll now0 = 0, now1 = 0;
	long long sum = 0;
	dpp[0] = 0;
	to[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++;
		}
		dpp[now1] = max(dpp[now1], sum);
		if (to[now1] == -1) {
			to[now1] = now0;
		}
	}
	dpnp = dpp;
	all.push_back(vector<pair<ll, ll>>(0));
	for (ll i = 1; i < n; i++) {
		vector<long long> ndpp(all[i + 1].size() + 1, -INF);
		vector<long long> ndpnp(all[i + 1].size() + 1, -INF);
		vector<ll> nto(all[i + 1].size() + 1, -1);
		nto[0] = 0;
		long long s = 0;
		for (ll ct = 0; ct <= all[i].size(); ct++) {
			ll nowi = 0, nowip = 0, nowim = 0;
			long long nans = 0, s1 = s, s2 = 0;
			ndpp[0] = max(ndpp[0], dpp[ct]);
			ndpp[0] = max(ndpp[0], dpnp[ct]);
			ndpnp[0] = max(ndpnp[0], dpp[ct] - s1);
			ndpnp[0] = max(ndpnp[0], dpnp[ct] - s1);
			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) {
						nans -= all[i][nowi].second;
						s1 -= all[i][nowi].second;
					}
					nowi++;
				}
				if (nowip < all[i + 1].size() && nxt == all[i + 1][nowip].first) {
					nans += all[i + 1][nowip].second;
					nowip++;
				}
				if (nowim < all[i - 1].size() && nxt == all[i - 1][nowim].first) {
					if (to[ct] <= nowim) {
						nans += all[i - 1][nowim].second;
						s2 += all[i - 1][nowim].second;
					}
					nowim++;
				}
				ndpp[nowip] = max(ndpp[nowip], nans + dpp[ct] - s2);
				ndpp[nowip] = max(ndpp[nowip], nans + dpnp[ct]);
				ndpnp[nowip] = max(ndpnp[nowip], nans + dpp[ct] - s2 - s1);
				ndpnp[nowip] = max(ndpnp[nowip], nans + dpnp[ct] - s1);
				if (nto[nowip] == -1) {
					nto[nowip] = nowi;
				}
			}
			if (ct < all[i].size()) {
				s += all[i][ct].second;
			}
		}
		dpp = ndpp;
		dpnp = ndpnp;
		to = nto;
	}
	long long ans = 0;
	for (auto i : dpp) {
		ans = max(ans, i);
	}
	for (auto i : dpnp) {
		ans = max(ans, i);
	}
	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