#!/usr/bin/env python3
oo = 1<<60

def best_alloc(M, L1, S1, L2, S2):
    # maximize x*S1 + y*S2
    # subject to
    #   x + 2*y = M,    0 <= x <= L1,   0 <= y <= L2,   x, y integers
    if M < 0 or L1 + 2*L2 < M or (M % 2 and L1 == 0): return -oo
    res = (M % 2) * S1
    L1 -= M % 2
    M -= M % 2
    if S2 > 2*S1:
        y = min(L2, M//2)
        x = M - 2*y
    else:
        x = min(L1, M)
        if x % 2: x -= 1
        y = (M-x) // 2
    return res + x*S1 + y*S2


def solve0(X, L, R, M):
    n = len(X)-1
    Lsum = [0]*(n+1)
    Rsum = [0]*(n+1)
    for i in range(n):
        Lsum[i+1] = Lsum[i] + L[i]*(X[i+1]-X[i])
        Rsum[i+1] = Rsum[i] + R[i]*(X[i+1]-X[i])
    Score = [[0]*(n+1) for _ in range(n+1)]
    for i in range(n+1):
        for j in range(n+1):
            Score[i][j] = Rsum[j]-Rsum[i] if i < j else Lsum[i] - Lsum[j]

    ans = 0
    
    # no turns
    for i in range(n+1):
        for j in range(i, n+1):
            if X[j] - X[i] == M:
                ans = max(ans, Score[i][j])
            if X[j] - X[i] >= M: break
            if j < n and X[j+1] - X[i] > M:
                ans = max(ans, Score[i][j] + (M - (X[j]-X[i]))*R[j])

    # one turn
    for i1 in range(n):
        i2 = i1
        i3 = 0
        while i2 <= n:
            if X[i2]-X[i1] > M: break
            rem = M - (X[i2]-X[i1] + X[i2]-X[i3])
            Lroom = X[i3]-X[i3-1] if i3 > 0 else 0
            Lscore = L[i3-1] if i3 > 0 else 0
            Rroom = X[i2+1]-X[i2] if i2 < n else 0
            Rscore = R[i2] + L[i2] if i2 < n else 0
            ans = max(ans, Score[i1][i2] + Score[i2][i3] + best_alloc(rem, Lroom, Lscore, Rroom, Rscore))
            if rem - 2*Rroom < 0:
                i3 += 1
            if rem - 2*Rroom >= 0 or i2 < i3:
                i2 += 1

    # two turns, first at breakpoint
    for i1 in range(n):
        for i2 in range(i1, n+1):
            i3 = i4 = 0
            while i4 <= i1:
                rem = M - ((X[i2] - X[i1]) + (X[i2] - X[i3]) + (X[i4] - X[i3]))
                Lroom = X[i3] - X[i3-1] if i3 > 0 else 0
                Rroom = X[i4+1] - X[i4] if i4 < i1 else 0
                Lscore = L[i3-1] + R[i3-1] if i3 > 0 else 0
                Rscore = R[i4]
                ans = max(ans, Score[i1][i2] + Score[i2][i3] + Score[i3][i4] + best_alloc(rem, Rroom, Rscore, Lroom, Lscore))
                if rem - Rroom < 0:
                    i3 += 1
                if rem - Rroom >= 0 or i4 < i3:
                    i4 += 1

    # two turns, second at breakpoint
    for i1 in range(n):
        for i3 in range(i1):
            i2 = i4 = i1
            while i4 >= i3 and i2 <= n:
                rem = M - ((X[i2] - X[i1]) + (X[i2] - X[i3]) + (X[i4] - X[i3]))
                Lroom = X[i4+1] - X[i4] if i4 < i1 else 0
                Rroom = X[i2+1] - X[i2] if i2 < n else 0
                Lscore = R[i4]
                Rscore = L[i2] + R[i2] if i2 < n else 0
                score = Score[i1][i2] + Score[i2][i3] + Score[i3][i4] + best_alloc(rem, Lroom, Lscore, Rroom, Rscore)
                ans = max(ans, score)
                if rem - 2*Rroom < 0:
                    i4 -= 1
                else:
                    i2 += 1
    
    return ans
                

def solve(X, L, R, M):
    mX = X[-1]
    revX = list(reversed([mX-x for x in X]))
    revL = list(reversed(L))
    revR = list(reversed(R))
    a1 = solve0(X, L, R, M)
    a2 = solve0(X, R, L, M)
    a3 = solve0(revX, revL, revR, M)
    a4 = solve0(revX, revR, revL, M)
    return max(a1, a2, a3, a4)


(m, x, n) = map(int, input().split())

X = {0, m}
LI = []
RI = []
for _ in range(n):
    (start, stop, val) = map(int, input().split())
    X |= {start, stop}
    if start < stop: RI.append((start, stop, val))
    else: LI.append((stop, start, val))

LI.sort()
RI.sort()
X = list(sorted(X))
L = []
R = []
Li = Ri = 0
for i in range(len(X)-1):
    while Li < len(LI) and LI[Li][1] <= X[i]:
        Li += 1
    L.append(LI[Li][2] if Li < len(LI) and LI[Li][0] <= X[i] else 0)
    while Ri < len(RI) and RI[Ri][1] <= X[i]:
        Ri += 1
    R.append(RI[Ri][2] if Ri < len(RI) and RI[Ri][0] <= X[i] else 0)

print(solve(X, L, R, x))