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: Time Limit Exceeded)

#include<iostream>
#include<iomanip>
#include<vector>
#include<algorithm>
#include<unordered_map>
typedef unsigned long long ull;
typedef signed long long sll;
using namespace std;

#define INF 0x7FFFFFFFFFFFFFFF
#define BIG_PRIME 1000000007

#define DEP 19
vector<sll> data;

void Add(sll l,sll r,sll a,sll k=0,sll s=0,sll t=-1)
{
  if(t<0)t=(1<<(DEP-1));
  if(t<=l||r<=s)return;
  if(l<=s&&t<=r)
  {
    data[k]+=a;
    return;
  }
  Add(l,r,a,2*k+1,s,(s+t)/2);
  Add(l,r,a,2*k+2,(s+t)/2,t);
}

sll Max(sll l,sll r, sll k=0,sll s=0,sll t=-1)
{
  if(t<0)t=(1<<(DEP-1));
  if(s+1==t)return data[k];
  if(t<=l||r<=s)return -INF;
  
  data[2*k+1]+=data[k];
  data[2*k+2]+=data[k];
  data[k]=0;
  return max(Max(l,r,2*k+1,s,(s+t)/2),
             Max(l,r,2*k+2,(s+t)/2,t));
}
sll Max(sll n)
{
  return Max(0,n+1);
}

vector<vector<pair<sll,sll>>> R;

int main()
{
  data.resize(1<<DEP,0);
  ull i,j,N,M;
  sll l,r,a;
  cin >> N >> M;
  R.resize(N+1);
  for(i=0;i<M;++i)
  {
    cin >> l >> r >> a;
    R[r].push_back(make_pair(l,a));
  }
  
  for(i=1;i<=N;++i)
  {
    Add(i,i+1,Max(i-1));
    for(auto itr:R[i])
    {
      Add(itr.first,i+1,itr.second);
    }
  }
  
  cout << Max(N);

  return 0;
}