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 (GCC 5.4.1) (judge verdict: Accepted)

long max(a,b)long a,b;{return a<b?b:a;}
int n;
long dat[1<<19],lazy[1<<19];
init(n_)
{
	n=1;
	while(n<n_)n<<=1;
}
eval(i,l,r)
{
	if(lazy[i])
	{
		dat[i]+=lazy[i];
		if(r-l>1)
		{
			lazy[2*i+1]+=lazy[i];
			lazy[2*i+2]+=lazy[i];
		}
		lazy[i]=0;
	}
}
update(a,b,x,k,l,r)long x;
{
	eval(k,l,r);
	if(b<=l||r<=a)return 0;
	else if(a<=l&&r<=b)
	{
		lazy[k]+=x;
		eval(k,l,r);
	}
	else
	{
		update(a,b,x,2*k+1,l,(l+r)/2);
		update(a,b,x,2*k+2,(l+r)/2,r);
		dat[k]=max(dat[2*k+1],dat[2*k+2]);
	}
}
long query(a,b,k,l,r)
{
	eval(k,l,r);
	if(b<=l||r<=a)return 0;
	else if(a<=l&&r<=b)return dat[k];
	else return max(
		query(a,b,2*k+1,l,(l+r)/2),
		query(a,b,2*k+2,(l+r)/2,r)
	);
}
int N,m;
L[1<<18],R[1<<18],A[1<<18];
first[1<<18],next[1<<18];
main()
{
	scanf("%d%d",&N,&m);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",L+i,R+i,A+i);
	}
	for(int i=1;i<=m;i++)
	{
		next[i]=first[R[i]];
		first[R[i]]=i;
	}
	init(N+1);
	//lazysegtree dp(n+1);
	for(int i=1;i<=N;i++)
	{
		update(i,i+1,query(0,i,0,0,n),0,0,n);
		int p=first[i];
		for(;p!=0;)
		{
			update(L[p],i+1,1L*A[p],0,0,n);
			//printf("%d %d %d\n",L[p],R[p],A[p]);
			p=next[p];
		}
		//puts("");
	}
	printf("%ld",query(0,N+1,0,0,n));
}