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 (Python):
import sys
readline = sys.stdin.readline

N, M = map(int, readline().split())
L = [[] for i in range(N+1)]
R = [[] for i in range(N+1)]
for i in range(M):
    l, r, a = map(int, readline().split())
    L[l-1].append((r, a))

INF = 2**31-1

LV = (N).bit_length()
N0 = 2**LV
data = [0]*(2*N0)
lazy = [0]*(2*N0)

I = []; K = []
for x in range(N0+1):
    y = N0 + x
    z = (y // (y & -y)) >> 1
    K.append(z)
    r = []
    while z:
        r.append(z)
        z >>= 1
    r.reverse()
    I.append(r)
I.append([])

J = []
for x in range(N0+1):
    y = N0 + x + 1
    z = (y // (y & -y)) - 1
    J.append(z-1 if z else 0)

def propagates(ids):
    for i in ids:
        v = lazy[i-1]
        if not v:
            continue
        lazy[2*i-1] += v; lazy[2*i] += v
        data[2*i-1] += v; data[2*i] += v
        lazy[i-1] = 0


def update(r, x):
    

    i = r
    while i:
        v = J[i-1]
        lazy[v] += x; data[v] += x
        i -= (i & -i)

    k = K[r]
    while k:
        data[k-1] = max(data[2*k-1], data[2*k]) + lazy[k-1]
        k >>= 1


def update1(k, x):
    
    k += N0
    data[k-1] += x
    while k:
        k >>= 1
        data[k-1] = max(data[2*k-1], data[2*k]) + lazy[k-1]



def query(r):
    return max(map(data.__getitem__, qquery(r)))

def qquery(r):
    propagates(I[r])

    while r:
        yield J[r-1]
        r -= (r & -r)


def query1(k, x):
    propagates(I[k])
    return data[k + N0 - 1]


for i in range(N):
    for r, a in L[i]:
        update(i+1, a)
        R[r].append((i, a))
    for l, a in R[i]:
        update(l+1, -a)
    v = query(i+1)
    update1(i+1, v)
for l, a in R[N]:
    update(l+1, -a)
sys.stdout.write("%d\n" % query(N+1))