#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()
#define INF (sizeof(int) == 4 ? (int)1e9:(int)1e18)
#define EPS 0.0000000001
template<class T, class S> void cmin(T &a, const S &b) { if (a > b)a = b; }
template<class T, class S> void cmax(T &a, const S &b) { if (a < b)a = b; }
template<typename Head, typename Value> auto vectors(const Head &head, const Value &v) { return vector<Value>(head, v); }
template<typename Head, typename... Tail> auto vectors(Head x, Tail... tail) { auto inner = vectors(tail...); return vector<decltype(inner)>(x, inner); }
using ld  = long double;
using pii = pair<int,int>;
using piii = pair<int,pii>;
int W,H;
int dx[]={0,0,1,-1}, dy[]={1,-1,0,0};
bool valid(int x,int y){return (0<=x&&x<W)&&(0<=y&&y<H);}
// Segment Tree Beats
// - l<=i<r について、 A_i の値を min(A_i, x) に更新
// - l<=i<r について、 A_i の値を max(A_i, x) に更新
// - l<=i<r の中の A_i の最大値を求める
// - l<=i<r の中の A_i の最小値を求める
// - l<=i<r の A_i の和を求める
// - l<=i<r について、 A_i の値に x を加える
// - l<=i<r について、 A_i の値を x に更新

class SegmentTree {
    const ll inf = 1e18;
    static const int N = 1e5 + 10;
    int n, n0;
    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];
    
    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);
    }
};

signed main(){
    int N; cin >> N;
    int M; cin >> M;
    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,mini + c);
        }
    }
    cout << (sgt.query_min(N,N+1) == INF ? -1 : sgt.query_min(N,N+1)  ) << endl;
}
