#include <bits/stdc++.h>

#define el '\n'
#define fi first
#define sec second
#define pb push_back
#define ll long long
#define sz(v) (int)(v).size()
#define all(v) (v).begin(),(v).end()

using namespace std;

const int MAX_N = 1e5 + 1;

struct Segment_Tree{
    ll tree[4 * MAX_N + 5];

    void update(int id, int l, int r, int pos, ll val){
        if(l == r){
            tree[id] = min(tree[id], val);
            return;
        }

        int m = (l + r) / 2;
        if(pos <= m) update(id * 2, l, m, pos, val);
        else update(id * 2 + 1, m + 1, r, pos, val);

        tree[id] = min(tree[id * 2], tree[id * 2 + 1]);
    }

    ll query(int id, int tl, int tr, int l, int r){
        if(tl > tr || l > r || r < tl || tr < l) return 1e18;
        if(l <= tl && tr <= r) return tree[id];

        int tm = (tl + tr) / 2;
        return min(query(id * 2, tl, tm, l, r),
                   query(id * 2 + 1, tm + 1, tr, l, r));
    }
}seg;

struct Hao{
    int in, out, cost;

    bool operator <(const Hao &other){
        if(in != other.in) return in < other.in;
        return in < other.in; // sort theo in
    }
};

Hao a[MAX_N + 5];
ll dp[MAX_N + 5];
int n, m;

// mình không thích thời gian bắt đầu từ 0 nên mình sẽ cộng 1 ở mọi chỗ để thời gian bắt đầu từ 1(không làm cũng được)
void Input(){
    cin >> n >> m;
    n++;

    for(int i = 1; i <= m; i++){
        cin >> a[i].in >> a[i].out >> a[i].cost;
        a[i].in++;
        a[i].out = min(a[i].out + 1, n); // sẽ có 1 số cái lớn hơn n nên phải lấy min(a[i].out, n)
    }
    sort(a + 1, a + m + 1);
}

void Solve(){
	// khởi tạo ban đầu mọi thứ lớn vô cùng
    memset(dp, 0x3f, sizeof(dp));
    memset(seg.tree, 0x3f, sizeof(seg.tree));
    
    //gán thời gian ban đầu 1 là 0
    seg.update(1, 1, n, 1, 0);
    dp[1] = 0;

    for(int i = 1; i <= m; i++){
    	//tìm dp bé nhất trong đoạn a[i].in -> a[i].out
    	//lấy từ a[i].in chứ không phải a[i].in - 1 là do tất cả các đoạn phải nối nhau
    	// ví dụ như [3, 4] và [5, 6] thì không được nhưng [3, 4] và [4, 6] mới được
        ll best = seg.query(1, 1, n, a[i].in, a[i].out);
        
        //tính dp
        dp[a[i].out] = min(dp[a[i].out], best + a[i].cost);
        
        //update lại
        seg.update(1, 1, n, a[i].out, dp[a[i].out]);
    }

	//cout kết quả
    cout << dp[n];
}

int main(){
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    Input();
    Solve();
}