#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rep(i,n) for(int i=0;i<n;i++)
#define all(in) in.begin(), in.end()
constexpr int inf = (long long)1e18;
//seg_beats_libray created by : https://gist.github.com/tjkendev/0965bdcf9e3c1063a7f2e76005d285ca#file-sgtbeats-task4-1-implement-cpp

static const int N = 1e6 + 10;
ll max_v[4*N], smax_v[4*N], max_c[4*N];
ll min_v[4*N], smin_v[4*N], min_c[4*N];
ll sum[4*N];

class SegmentTree {
    int n, n0;
    void update_node_max(int k, ll x) {
        sum[k] += (x - max_v[k]) * max_c[k];
        
        if(max_v[k] == min_v[k]) {
            max_v[k] = min_v[k] = x;
        } else if(max_v[k] == smin_v[k]) {
            max_v[k] = smin_v[k] = x;
        } else {
            max_v[k] = x;
        }
    }
    void update_node_min(int k, ll x) {
        sum[k] += (x - min_v[k]) * min_c[k];
        
        if(max_v[k] == min_v[k]) {
            max_v[k] = min_v[k] = x;
        } else if(smax_v[k] == min_v[k]) {
            min_v[k] = smax_v[k] = x;
        } else {
            min_v[k] = x;
        }
    }
    
    void push(int k) {
        if(max_v[k] < max_v[2*k+1]) {
            update_node_max(2*k+1, max_v[k]);
        }
        if(min_v[2*k+1] < min_v[k]) {
            update_node_min(2*k+1, min_v[k]);
        }
        
        if(max_v[k] < max_v[2*k+2]) {
            update_node_max(2*k+2, max_v[k]);
        }
        if(min_v[2*k+2] < min_v[k]) {
            update_node_min(2*k+2, min_v[k]);
        }
    }
    
    void update(int k) {
        sum[k] = sum[2*k+1] + sum[2*k+2];
        
        if(max_v[2*k+1] < max_v[2*k+2]) {
            max_v[k] = max_v[2*k+2];
            max_c[k] = max_c[2*k+2];
            smax_v[k] = max(max_v[2*k+1], smax_v[2*k+2]);
        } else if(max_v[2*k+1] > max_v[2*k+2]) {
            max_v[k] = max_v[2*k+1];
            max_c[k] = max_c[2*k+1];
            smax_v[k] = max(smax_v[2*k+1], max_v[2*k+2]);
        } else {
            max_v[k] = max_v[2*k+1];
            max_c[k] = max_c[2*k+1] + max_c[2*k+2];
            smax_v[k] = max(smax_v[2*k+1], smax_v[2*k+2]);
        }
        
        if(min_v[2*k+1] < min_v[2*k+2]) {
            min_v[k] = min_v[2*k+1];
            min_c[k] = min_c[2*k+1];
            smin_v[k] = min(smin_v[2*k+1], min_v[2*k+2]);
        } else if(min_v[2*k+1] > min_v[2*k+2]) {
            min_v[k] = min_v[2*k+2];
            min_c[k] = min_c[2*k+2];
            smin_v[k] = min(min_v[2*k+1], smin_v[2*k+2]);
        } else {
            min_v[k] = min_v[2*k+1];
            min_c[k] = min_c[2*k+1] + min_c[2*k+2];
            smin_v[k] = min(smin_v[2*k+1], smin_v[2*k+2]);
        }
    }
    
    void _update_min(ll x, int a, int b, int k, int l, int r) {
        if(b <= l || r <= a || max_v[k] <= x) {
            return;
        }
        if(a <= l && r <= b && smax_v[k] < x) {
            update_node_max(k, x);
            return;
        }
        
        push(k);
        _update_min(x, a, b, 2*k+1, l, (l+r)/2);
        _update_min(x, a, b, 2*k+2, (l+r)/2, r);
        update(k);
    }
    
    void _update_max(ll x, int a, int b, int k, int l, int r) {
        if(b <= l || r <= a || x <= min_v[k]) {
            return;
        }
        if(a <= l && r <= b && x < smin_v[k]) {
            update_node_min(k, x);
            return;
        }
        
        push(k);
        _update_max(x, a, b, 2*k+1, l, (l+r)/2);
        _update_max(x, a, b, 2*k+2, (l+r)/2, r);
        update(k);
    }
    
    ll _query_max(int a, int b, int k, int l, int r) {
        if(b <= l || r <= a) {
            return -inf;
        }
        if(a <= l && r <= b) {
            return max_v[k];
        }
        push(k);
        ll lv = _query_max(a, b, 2*k+1, l, (l+r)/2);
        ll rv = _query_max(a, b, 2*k+2, (l+r)/2, r);
        return max(lv, rv);
    }
    
    ll _query_min(int a, int b, int k, int l, int r) {
        if(b <= l || r <= a) {
            return inf;
        }
        if(a <= l && r <= b) {
            return min_v[k];
        }
        push(k);
        ll lv = _query_min(a, b, 2*k+1, l, (l+r)/2);
        ll rv = _query_min(a, b, 2*k+2, (l+r)/2, r);
        return min(lv, rv);
    }
    
    ll _query_sum(int a, int b, int k, int l, int r) {
        if(b <= l || r <= a) {
            return 0;
        }
        if(a <= l && r <= b) {
            return sum[k];
        }
        push(k);
        ll lv = _query_sum(a, b, 2*k+1, l, (l+r)/2);
        ll rv = _query_sum(a, b, 2*k+2, (l+r)/2, r);
        return lv + rv;
    }
    
public:
    
    SegmentTree(int n, vector<int>&a) : n(n) {
        n0 = 1;
        while(n0 < n) n0 <<= 1;
        
        for(int i=0; i<n; ++i) {
            max_v[n0-1+i] = min_v[n0-1+i] = sum[n0-1+i] = (a[i]);
            smax_v[n0-1+i] = -inf;
            smin_v[n0-1+i] = inf;
            max_c[n0-1+i] = min_c[n0-1+i] = 1;
        }
        for(int i=n; i<n0; ++i) {
            max_v[n0-1+i] = smax_v[n0-1+i] = -inf;
            min_v[n0-1+i] = smin_v[n0-1+i] = inf;
            max_c[n0-1+i] = min_c[n0-1+i] = 0;
        }
        for(int i=n0-2; i>=0; i--) update(i);
    }
    
    void update_min(int a, int b, ll x) {
        return _update_min(x, a, b, 0, 0, n0);
    }
    
    void update_max(int a, int b, ll x) {
        return _update_max(x, a, b, 0, 0, n0);
    }
    
    ll query_max(int a, int b) {
        return _query_max(a, b, 0, 0, n0);
    }
    
    ll query_min(int a, int b) {
        return _query_min(a, b, 0, 0, n0);
    }
    
    ll query_sum(int a, int b) {
        return _query_sum(a, b, 0, 0, n0);
    }
};
void solve(){
    vector<int>v(10, inf);
    auto sgt = SegmentTree(10,v);
    sgt.update_min(1,3,5);
    cout << sgt.query_min(1,2) << endl;
}
signed main(){
    int N; cin >> N;
    int M; cin >> M;
    //solve();
    using tp = tuple<int,int,int>;
    vector<tp>data;
    rep(i,M){
        int l,r,c;
        cin >> l >> r >> c;
        data.emplace_back(l,r,c);
    }
    sort(all(data));
    vector<int>v(N + 10, inf);
    auto sgt = SegmentTree(N +100,v);
    for(auto p : data){
        int l,r,c;
        tie(l,r,c) = p;
        if(sgt.query_min(l,r + 1) ==  inf){
            if(l == 1)
                sgt.update_min(l,r + 1,c);
        } else {
            int mini = sgt.query_min(l,r+1);
            sgt.update_min(l,r+1,(l == 1) ? c : mini + c);
        }
    }
    cout << (sgt.query_min(N,N+1) == inf ? -1 : sgt.query_min(N,N+1)  ) << endl;
}



Measured memory_bytes: 29808