Problem:
Score : 100 points

Problem Statement

Consider a string of length N consisting of 0 and 1.
The score for the string is calculated as follows:

For each i (1 \leq i \leq M), a_i is added to the score if the string contains 1 at least once between the l_i-th and r_i-th characters (inclusive).

Find the maximum possible score of a string.

Constraints

All values in input are integers.

1 \leq N \leq 2 × 10^5

1 \leq M \leq 2 × 10^5

1 \leq l_i \leq r_i \leq N

|a_i| \leq 10^9

Input

Input is given from Standard Input in the following format:

N M
l_1 r_1 a_1
l_2 r_2 a_2
:
l_M r_M a_M

Output

Print the maximum possible score of a string.

Sample Input 1

5 3
1 3 10
2 4 -10
3 5 10

Sample Output 1

20

The score for 10001 is a_1 + a_3 = 10 + 10 = 20.

Sample Input 2

3 4
1 3 100
1 1 -10
2 2 -20
3 3 -30

Sample Output 2

90

The score for 100 is a_1 + a_2 = 100 + (-10) = 90.

Sample Input 3

1 1
1 1 -10

Sample Output 3

0

The score for 0 is 0.

Sample Input 4

1 5
1 1 1000000000
1 1 1000000000
1 1 1000000000
1 1 1000000000
1 1 1000000000

Sample Output 4

5000000000

The answer may not fit into a 32-bit integer type.

Sample Input 5

6 8
5 5 3
1 1 10
1 6 -8
3 6 5
3 4 9
5 5 -2
1 3 -6
4 6 -7

Sample Output 5

10

For example, the score for 101000 is a_2 + a_3 + a_4 + a_5 + a_7 = 10 + (-8) + 5 + 9 + (-6) = 10.

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include <bits/stdc++.h>
//~ #include <ext/pb_ds/assoc_container.hpp>
//~ #include <ext/pb_ds/tree_policy.hpp>
using namespace std;
//~ using namespace __gnu_pbds; 
#define mp make_pair
#define endl '\n'
typedef long long ll;
 
const int INF=1e9+5;
const ll lim=(ll)3e16;
const int N=2e5+5;
const int mod=1e9+7;	
const ll oo=1e18+5;

//~ typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;

class IT{
	struct node{
		int left,right;
		ll val,lazy;
	};
	vector<node> a;
	void push_down(int id){
		ll plus=a[id].lazy;
		a[id].lazy=0;
		a[id<<1].val+=plus;
		a[id<<1].lazy+=plus;
		a[id<<1|1].val+=plus;
		a[id<<1|1].lazy+=plus;
	}
	void push_up(int id){
		a[id].val=max(a[id<<1].val,a[id<<1|1].val);
	}
	void build(int l,int r,int id){
		a[id].left=l,a[id].right=r;
		if(l==r) return;
		int mid=(l+r)>>1;
		build(l,mid,id<<1);
		build(mid+1,r,id<<1|1);
	}
	public:
	IT(int n):a(n<<2){
		build(0,n,1);
	}
	void add(int l,int r,ll val,int id=1){
		if(a[id].left>=l&&a[id].right<=r){
			a[id].val+=val;
			a[id].lazy+=val;
			return;
		}
		push_down(id);
		int mid=(a[id].left+a[id].right)>>1;
		if(l<=mid) add(l,r,val,id<<1);
		if(r>mid) add(l,r,val,id<<1|1);
		push_up(id);
	}
	ll get_max(int l,int r,int id=1){
		if(l<=a[id].left&&a[id].right<=r) return a[id].val;
		push_down(id);
		ll maxx=-9e18;
		int mid=(a[id].left+a[id].right)>>1;
		if(l<=mid) maxx=max(maxx,get_max(l,r,id<<1));
		if(r>mid) maxx=max(maxx,get_max(l,r,id<<1|1));
		push_up(id);
		return maxx;
	}
};

int main(){
	ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(0);
	int n,m;
	cin>>n>>m;
	vector<ll> beg(n+1);
	vector<vector<pair<int,ll>>> fin(n+1);
	for(int i=0;i<m;++i){
		int l,r;
		ll val;
		cin>>l>>r>>val;
		beg[l]+=val;
		fin[r].emplace_back(l,val);
	}
	IT tree(n+1);
	ll ans=0;
	for(int i=1;i<=n;++i){
		// put 1 here 
		// add all vals start from i
		tree.add(0,i-1,beg[i]);
		ll cur_max=tree.get_max(0,i-1); 
		ans=max(ans,cur_max);
		tree.add(i,i,cur_max); // add cur in here 
		for(pair<int,ll> x:fin[i]){
			tree.add(0,x.first-1,-x.second);
		}
	}
	cout<<ans;
	return 0;	
}