/////////////////////////////////////////////////
//                                             //
//                 _ooOoo_                     //
//                o8888888o                    //
//                88" . "88                    //
//                (| -_- |)                    //
//             ____/`---'\\____                //
//           .'  \|     |//  `.                //
//           /  \|||  :  |||// \               //
//          /  _||||| -:- |||||- \             //
//          |   | \\  -  /// |   |             //
//          | \_|  ''\---/''  |  |             //
//          \  .-\__  `-`  ___/-. /            //
//         ___`. .'  /--.--\  `. . __          //
//      ."" '<  `.___\_<|>_/___.'  >'"".       //
//     | | :  `- \`.;`\ _ /`;.`/ - ` : | |     //
//     \  \ `-.   \_ __\ /__ _/   .-` /  /     //
//=====`-.____`-.___\_____/___.-`____.-'=======//
//^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^//
//.............................................//
/////////////////////////////////////////////////

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll modn=998244353;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;
ll tr[1001000];
ll lazy[1001000];
int lazy_flag[1001000];
struct node{
    int l;int r;int c;
};
node edges[1001000];
bool operator <(const node &a,const node &b){
    if(a.l==b.l){
        if(a.r==b.r){
            return a.c<b.c;
        }
        return a.r<b.r;
    }
    return a.l<b.l;
}
void build(int o,int l,int r){
    if(l==r){
        if(l==1)
            tr[o]=0;
        else
            tr[o]=INF;
        lazy[o]=INF;
        return;
    }
    int mid = (l+r)/2;
    build(o*2+1,l,mid);
    build(o*2+2,mid+1,r);
    lazy[o]=INF;
    tr[o]=min(tr[o*2+1],tr[o*2+2]);
}
void push_down(int o){
    if(lazy_flag[o]){
        lazy_flag[o*2+1]=1;
        lazy_flag[o*2+2]=1;
        lazy[o*2+1]=min(lazy[o*2+1],lazy[o]);
        lazy[o*2+2]=min(lazy[o*2+2],lazy[o]);
        tr[o*2+1]=min(tr[o*2+1],lazy[o]);
        tr[o*2+2]=min(tr[o*2+2],lazy[o]);
        lazy[o]=INF;
        lazy_flag[o]=0;
    }
}
void push_up(int o){
    tr[o]=min(tr[o*2+1],tr[o*2+2]);
}

ll query(int o,int l,int r,int pos){
    //cout<<l<<r<<endl;
    if(l==r){
        return tr[o];
    }
    push_down(o);
    int mid = (l+r)/2;
    ll ans;
    if(pos<=mid)ans = query(o*2+1,l,mid,pos);
    else  ans = query(o*2+2,mid+1,r,pos);
    push_up(o);
    return ans;
}

void ins(int o,int L,int R,int l,int r,ll val){
    //cout<<L<<R<<" "<<l<<r<<endl;
    if(l<=L && r>=R){
        lazy_flag[o]=1;
        lazy[o]=min(lazy[o],val);
        tr[o]=min(tr[o],val);
        return;
    }
    push_down(o);
    int mid = (L+R)/2;
    if(l<=mid)ins(o*2+1,L,mid,l,r,val);
    if(r>mid)ins(o*2+2,mid+1,R,l,r,val);
    push_up(o);
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    build(0,1,n);
    for(int i=0;i<m;i++){
        scanf("%d%d%d",&edges[i].l,&edges[i].r,&edges[i].c);
    }
    sort(edges,edges+m);
    for(int i=0;i<m;i++){
        ll val = query(0,1,n,edges[i].l);
        val += edges[i].c;
        //cout<<edges[i].l<<edges[i].r<<" " <<val<<endl;
        ins(0,1,n,edges[i].l+1,edges[i].r,val);
        //cout<<"query"<<i<<" "<<query(0,1,n,n)<<endl;
    }
    ll ans = query(0,1,n,n);
    if(ans >=INF)
        printf("-1\n");
    else
        printf("%lld\n",ans);
    return 0;
}



Measured memory_bytes: 13696