#![allow(unused)]

// ///////////////
// Lazy SegTree //
// ///////////////

// struct Delta {
//     value: Modulo,
//     mask: usize,
// }
//
// impl Default for Delta {
//     fn default() -> Self {
//         Self {
//             value: Modulo::new(1),
//             mask: 0,
//         }
//     }
// }
//
// impl Delta {
//     fn new(value: Modulo, mask: usize) -> Self {
//         Self { value, mask }
//     }
// }
//
// impl std::ops::Add for Delta {
//     type Output = Self;
//
//     fn add(self, rhs: Self) -> Self::Output {
//         let value = self.value * rhs.value;
//         let mask = self.mask | rhs.mask;
//         Self { value, mask }
//     }
// }
//
// #[derive(Default, Copy, Clone)]
// struct Node {
//     value: Modulo,
//     mask: usize,
//     size: usize,
// }
//
// impl Node {
//     fn new(value: Modulo) -> Self {
//         Self {
//             value,
//             mask: 0,
//             size: 1,
//         }
//     }
//     fn new_by_child(l: Self, r: Self) -> Self {
//         Self {
//             value: l.value + r.value,
//             mask: l.mask | r.mask,
//             size: l.size + r.size,
//         }
//     }
// }

use proconio::marker::Usize1;

struct LazySegTree<Node, Delta, NodeMerge, ApplyDelta, UpdateDelta> {
    n: usize,
    tree_height: usize,
    tree: Vec<(Node, Delta)>,
    node_init: Node,
    delta_init: Delta,
    node_merge: NodeMerge,
    apply_delta: ApplyDelta,
    update_delta: UpdateDelta,
}

impl<Node, Delta, NodeMerge, ApplyDelta, UpdateDelta>
    LazySegTree<Node, Delta, NodeMerge, ApplyDelta, UpdateDelta>
where
    Node: Copy,
    Delta: Copy,
    NodeMerge: Fn(Node, Node) -> Node,
    ApplyDelta: Fn(Node, Delta) -> Node,
    UpdateDelta: Fn(Delta, Delta) -> Delta,
{
    fn new(
        n: usize,
        node_init: Node,
        delta_init: Delta,
        node_merge: NodeMerge,
        apply_delta: ApplyDelta,
        update_delta: UpdateDelta,
    ) -> Self {
        let mut tree_height = 1;
        while (1 << tree_height) < n {
            tree_height += 1;
        }
        Self {
            n,
            tree_height,
            tree: vec![(node_init, delta_init); n * 2],
            node_init,
            delta_init,
            node_merge,
            apply_delta,
            update_delta,
        }
    }

    fn evaluate(&self, i: usize) -> Node {
        (self.apply_delta)(self.tree[i].0, self.tree[i].1)
    }

    fn query(&mut self, l: usize, r: usize) -> Node {
        if l >= r {
            return self.node_init;
        }
        let mut l = l + self.n;
        let mut r = r + self.n;
        self.propagate(l);
        self.propagate(r - 1);
        let mut lp = self.node_init;
        let mut rp = self.node_init;
        while l < r {
            if l & 1 == 1 {
                lp = (self.node_merge)(lp, self.evaluate(l));
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;
                rp = (self.node_merge)(self.evaluate(r), rp);
            }
            l /= 2;
            r /= 2;
        }
        (self.node_merge)(lp, rp)
    }

    fn update(&mut self, l: usize, r: usize, delta: Delta) {
        if l >= r {
            return;
        }

        let mut l = l + self.n;
        let mut r = r + self.n;
        self.propagate(l);
        self.propagate(r - 1);
        let origin_l = l.clone();
        let origin_r = r.clone();

        while l < r {
            if l & 1 == 1 {
                self.tree[l].1 = (self.update_delta)(self.tree[l].1, delta);
                l += 1;
            }
            if r & 1 == 1 {
                r -= 1;
                self.tree[r].1 = (self.update_delta)(self.tree[r].1, delta);
            }
            l /= 2;
            r /= 2;
        }
        self.build(origin_l);
        self.build(origin_r - 1);
    }

    fn build(&mut self, node: usize) {
        let mut i = node / 2;
        while i > 0 {
            self.tree[i].0 = (self.node_merge)(self.evaluate(i * 2), self.evaluate(i * 2 + 1));
            i /= 2;
        }
    }

    fn propagate(&mut self, node: usize) {
        for h in (1..=self.tree_height).rev() {
            let i = node >> h;
            // TODO check dirty
            self.tree[2 * i].1 = (self.update_delta)(self.tree[i].1, self.tree[2 * i].1);
            self.tree[2 * i + 1].1 = (self.update_delta)(self.tree[i].1, self.tree[2 * i + 1].1);
            self.tree[i].0 = (self.node_merge)(self.evaluate(i * 2), self.evaluate(i * 2 + 1));
            self.tree[i].1 = self.delta_init;
        }
    }
}

fn main() {
    use proconio::*;
    input! {
    n: usize,
    m: usize,
    a: [(Usize1, Usize1, i64); m]
    }
    let mut q = vec![vec![]; n];
    for (l, r, a) in a {
        q[r].push((l, a));
    }
    let f = std::cmp::max;
    let g = |a: i64, b: i64| a + b;
    let h = |a: i64, b: i64| a + b;

    let mut tree = LazySegTree::new(n, 0, 0, f, g, h);
    for r in 0..n {
        let value = tree.query(0, r);
        tree.update(r, r + 1, value);

        for &(l, a) in &q[r] {
            tree.update(l, r + 1, a);
        }
    }
    let ans = tree.query(0, n);
    println!("{:?}", ans);
}


Measured memory_bytes: 23948