#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = (int)(a); i <= (int)(n); ++i)
#define rrep(i, a, n) for (int i = (int)(a); i >= (int)(n); --i)
#define debug(x) cerr << #x << " = " << x << "\n"
#define debugv(x) \
  rep(f, 0, (x.size() - 1)) cerr << x[f] << (f == (x.size() - 1) ? "\n" : " ")
#define debug2(x, y)                       \
  cerr << "(" << #x << "," << #y << ") = " \
       << "(" << x << "," << y << ")\n"
#define all(x) x.begin(), x.end()
#define each(a, x) for (auto &a : (x))
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define int long long
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int MX = 1e5 + 5, INF = 5LL << 57, MOD = 1e9 + 7;

int N, M;
string S;
vi va, vb;

int dat[6 * MX + 5];
int n;
void init(int n_) {
  n = 1;
  while (n < n_) {
    n *= 2;
  }
  for (int i = 0; i < 2 * n - 1; ++i) dat[i] = INF;
}
void update(int k, int a) {
  k += n - 1;
  chmin(dat[k], a);

  while (k > 0) {
    k = (k - 1) / 2;
    dat[k] = min(dat[k * 2 + 1], dat[k * 2 + 2]);
  }
}

// [a,b)の最小値を求める
int query(int a, int b, int k, int l, int r) {
  if (r <= a || b <= l) return INF;

  if (a <= l && r <= b)
    return dat[k];
  else {
    int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
    int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
    return min(vl, vr);
  }
}

// int g[MX + 1];
vector<tuple<int, int, int>> lrc;
vector<pii> lll[MX + 5];
void input() {
  // rep(i, 0, MX) { g[i] = INF; };
  cin >> N >> M;
  init(N * 2);
  rep(i, 1, M) {
    int l, r, c;
    cin >> l >> r >> c;
    lrc.push_back(tie(l, r, c));
    lll[r].push_back(pii(l, c));
  };
}
void solve() {
  // g[1] = 0;
  sort(all(lrc));

  //   int a, b, c;
  //   tie(a, b, c) = lrc[i];
  //   //   cout << a << " " << b << " " << c << endl;
  // };

  int ans = INF;
  update(0, 0);
  update(1, 0);
  //  for (auto x : lrc) {
  for (int R = 1; R <= N; ++R) {
    for (auto qs : lll[R]) {
      int L = qs.first;
      int C = qs.second;
      // debug2(L, R);
      int ds = query(L, N + 1, 0, 0, n);
      // debug(ds);
      update(R, ds + C);
      // debug(query(R, R + 1, 0, 0, n));
    }
    // debug2(R, dat[n - 1 + R]);
  }
  ans = query(N, N + 1, 0, 0, n);

  // for (int i = 0; i < N; ++i) {
  //   int a, b, c;
  //   tie(a, b, c) = lrc[i];
  //   // if (a == 1) {
  //   //   update(b, c);
  //   //   continue;
  //   // }
  //   int tmp = query(a, n + 1, 0, 0, n);
  //   // debug(tmp);
  //   if (tmp == INF) {
  //     cout << -1 << endl;
  //     return;
  //   }

  //   int kk = query(b, n + 1, 0, 0, n);
  //   update(b, min(kk, tmp + c));
  //   if ((i < N - 1) && (get<0>(lrc[i + 1]) <= b)) {
  //     int aa = get<0>(lrc[i + 1]);
  //     int ll = query(aa, n + 1, 0, 0, n);
  //     update(aa, min(ll, tmp + c));
  //   }
  //   if (b == N) {
  //     ans = min(ans, query(a, n + 1, 0, 0, n) + c);
  //   }
  // };
  // sort(all(lrc),
  //      [](const tuple<int, int, int> &a, const tuple<int, int, int> &b) {
  //        return get<1>(a) < get<1>(b);
  //      });

  // for (auto x : lrc) {
  //   int a, b, c;
  //   tie(a, b, c) = x;
  //   cout << a << " " << b << " " << c << endl;
  // };
  // // for (auto x : lrc) {
  // for (int i = 0; i < N; ++i) {
  //   int a, b, c;
  //   tie(a, b, c) = lrc[i];
  //   // if (a == 1) {
  //   //   update(b, c);
  //   //   continue;
  //   // }
  //   int tmp = query(a, b + 1, 0, 0, n);
  //   // debug(tmp);
  //   if (tmp == INF) {
  //     cout << -1 << endl;
  //     return;
  //   }

  //   int kk = query(b, b + 1, 0, 0, n);
  //   update(b, min(kk, tmp + c));

  //   if ((i < N - 1) && get<0>(lrc[i + 1]) <= b) {
  //     int aa = get<0>(lrc[i + 1]);
  //     int ll = query(aa, aa + 1, 0, 0, n);
  //     update(get<0>(lrc[i + 1]), min(ll, tmp + c));
  //   }
  //   if (b == N) {
  //     ans = min(ans, query(a, b + 1, 0, 0, n) + c);
  //   }
  // };
  cout << (ans == INF ? -1 : ans) << endl;
}
signed main() {
  input();
  solve();
  return 0;
}

Measured memory_bytes: 12980