use std::io::Read;

fn calc_segment_index(l: usize, r: usize, k: usize) -> Vec<usize> {
    let mut x = l + k;
    let mut y = r + k;
    let mut a = vec![];
    let mut b = vec![];
    while x < y {
        if x & 1 == 1 {
            a.push(x);
            x += 1;
        }
        if y & 1 == 1 {
            y -= 1;
            b.push(y);
        }
        x >>= 1;
        y >>= 1;
    }
    b.reverse();
    a.append(&mut b);
    a
}

fn run() {
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut it = s.trim().split_whitespace();
    let n: usize = it.next().unwrap().parse().unwrap();
    let m: usize = it.next().unwrap().parse().unwrap();
    let size = n.next_power_of_two();
    let mut graph = vec![vec![]; 3 * size + 2 * m];
    let mut up = vec![0; 2 * size];
    let mut down = vec![0; 2 * size];
    for i in 0..size {
        up[size + i] = i;
        down[size + i] = i;
    }
    for i in 1..(size + 1) {
        up[i] = size + i;
        down[i] = 2 * size + i;
    }
    for i in 1..size {
        graph[down[i]].push((down[2 * i    ], 0));
        graph[down[i]].push((down[2 * i + 1], 0));
        graph[up[2 * i    ]].push((up[i], 0));
        graph[up[2 * i + 1]].push((up[i], 0));
    }
    for i in 0..size {
        graph[i].push((up[size + i], 0));
        graph[down[size + i]].push((i, 0));
    }
    for k in 0..m {
        let l = it.next().unwrap().parse::<usize>().unwrap() - 1;
        let r = it.next().unwrap().parse::<usize>().unwrap();
        let c: i64 = it.next().unwrap().parse().unwrap();
        let s = 3 * size + k;
        let t = 3 * size + m + k;
        let a = calc_segment_index(l, r, size);
        for a in a {
            graph[up[a]].push((s, 0));
            graph[t].push((down[a], 0));
        }
        graph[s].push((t, c));
    }
    let len = graph.len();
    let mut dp = vec![std::i64::MAX; len];
    dp[0] = 0;
    let mut h = std::collections::BinaryHeap::new();
    h.push((0, 0));
    while let Some((d, v)) = h.pop() {
        let d = -d;
        if d > dp[v] {
            continue;
        }
        for &(u, c) in &graph[v] {
            let d = d + c;
            if d < dp[u] {
                dp[u] = d;
                h.push((-d, u));
            }
        }
    }
    if dp[n - 1] == std::i64::MAX {
        println!("-1");
    } else {
        println!("{}", dp[n - 1]);
    }

}

fn main() {
    run();
}
