#include<bits/stdc++.h>

#define ll long long
#define fornum(A,B,C) for(A=B;A<C;A++)
#define mp make_pair
#define pii pair<int,int>
#define pll pair<ll,ll>

using namespace std;

/////////////////////////////////////////////////////

enum SegType{SUM,MIN,MAX};
template<typename T>
struct SegTree{
    int num=0, bt;
    vector<T> node, lazy;
    function<T(const T &,const T &)> calc1;
    function<T(const int &, const int &, const int &, const int &, const T &)> calc2;
    function<T(const T &)> calc3;
    T _init;
    
    void init(int num,T n,SegType st){
        int i = 0, j = 1;
        this->num = num;
        if(st==SegType::MAX){
            this->_init = LLONG_MIN;
            this->calc1 = [](const T &a, const T &b) { return max(a, b); };
            this->calc2 = [](const int &x, const int &y, const int &l, const int &r, const T &n) { return n; };
            this->calc3 = [](const T &n) { return n; };
        }else if(st==SegType::MIN){
            this->_init = LLONG_MAX;
            this->calc1 = [](const T &a, const T &b) { return min(a, b); };
            this->calc2 = [](const int &x, const int &y, const int &l, const int &r, const T &n) { return n; };
            this->calc3 = [](const T &n) { return n; };
        }else if(st==SegType::SUM){
            this->_init = 0;
            this->calc1 = [](const T &a,const T &b) { return a + b; };
            this->calc2 = [](const int &x, const int &y, const int &l, const int &r, const T &n) { return (r - l + 1) * n; };
            this->calc3 = [](const T &n) { return n / 2; };
        }

        for (i = 0; j <= num;i++)
            j *= 2;
        bt = j - 1;

        node.resize(j * 2 - 1, n);
        lazy.resize(j * 2 - 1, 0);
        for (int i = 0; i < num; i++){
            node[bt + i] = n;
        }
        for (int i = bt - 1; i >= 0;i--){
            node[i]=calc1(node[i * 2 + 1], node[i * 2 + 2]);
        }
    }
    void addd(int x,int y,T n){
        if(x>y)
            swap(x, y);
        _addd(x, y, n, 0, 0, this->bt);
    }
    void _addd(const int& x,const int& y,const T& n,int p,int l,int r){
        if (r < x || y < l)
            return;
        if(x<=l&&r<=y){
            lazy[p] += calc2(x, y, l, r, n);
            evall(p);
        }else{
            _addd(x, y, n, p * 2 + 1, l, (l + r) / 2);
            _addd(x, y, n, p * 2 + 2, (l + r) / 2 + 1, r);
            node[p] = calc1(node[p * 2 + 1], node[p * 2 + 2]);
        }
    }
    inline void evall(int x){
        node[x] += lazy[x];
        if(x<bt){
            lazy[x * 2 + 1] += calc3(lazy[x]);
            lazy[x * 2 + 2] += calc3(lazy[x]);
        }
        lazy[x] = 0;
    }
    void sett(int x,T n){
        int i = bt+x;
        node[i] = n;
        while(i!=0){
            i = (i - 1) / 2;
            node[i] = calc1(node[i * 2 + 1],node[i * 2 + 2]);
        }
    }
    inline T gett(int x){
        return node[bt + x];
    }
    T gett(int x,int y){
        T ret=_init;
        if(x>y)
            swap(x, y);
        _gett(x, y, 0, 0, this->bt, ret);
        return ret;
    }
    void _gett(const int& x,const int& y,int p,int l,int r,T& ret){
        //printf("%d,%d,%d,%d\n", x, y, l, r);
        if(r<x||y<l)
            return;
        if(lazy[p]!=0)
            evall(p);
        if(x<=l&&r<=y){
            ret = calc1(ret, node[p]);
            //printf("%d,%d,%d,%d:%lld\n", x, y, l, r, ret);
            return;
        }
        _gett(x, y, p * 2 + 1, l, (l + r) / 2, ret);
        _gett(x, y, p * 2 + 2, (l + r) / 2 + 1, r, ret);
    }
};

ll N,M;
vector<pair<pll,ll>> LRC;
ll dp[101010];
deque<pll> sld;
SegTree<ll> sg;
ll i, j, k, l;

int main(){
    scanf("%lld%lld", &N,&M);
    fornum(i,0,M){
        ll l, r, c;
        scanf("%lld%lld%lld", &l, &r, &c);
        LRC.push_back({{l, r}, c});
    }
    sort(LRC.begin(), LRC.end());
    j = 0;
    ll ans = 0;
    sg.init(N + 1, 1e17, SegType::MIN);
    sg.sett(1, 0);
    fornum(i,1,N){
        //printf("%lld,%lld\n", i, dp[i]);
        while(j<M&&LRC[j].first.first==i){
            //printf("%lld,%lld,%lld\n", 
            //LRC[j].first.first, LRC[j].first.second, LRC[j].second);
            sld.push_back({LRC[j].first.second, LRC[j].second});
            j++;
        }
        if(sg.gett(i)==1e17)
            continue;
        while(sld.size()){
            pll a = sld.front();
            //printf("%lld %lld\n", a.first, a.second);
            sg.sett(a.first, min(sg.gett(a.first), sg.gett(i, a.first - 1) + a.second));
            sld.pop_front();
        }
    }
    if(sg.gett(N)==1e17){
        printf("-1");
    }else
    printf("%lld", sg.gett(N));

    return 0;
}

Measured memory_bytes: 8048