#include <bits/stdc++.h>
const int INF = 2147483647;
const long long int MOD = 1000000007;
using namespace std;
template <class T>
class SegmentTree {
 public:
  SegmentTree(const int n, const T id, function<T(T, T)> op,
              function<T(T, T)> updateOp);
  void update(const int index, const T value);
  T find(const int l, const int r);

 private:
  int leftChildIndex(const int parent);
  int rightChildIndex(const int parent);
  int parent(const int child);
  int leaf(const int index);
  T query(const int l, const int r, const int node, const int al, const int ar);

 private:
  vector<T> data;
  int leafNum;
  T id;
  function<T(T, T)> op;
  function<T(T, T)> updateOp;
};
template <class T>
SegmentTree<T>::SegmentTree(const int n, const T id, function<T(T, T)> op,
                            function<T(T, T)> updateOp)
    : id(id), op(op), updateOp(updateOp) {
  leafNum = 1;
  while (leafNum < n) leafNum *= 2;
  data = vector<T>(2 * leafNum - 1, id);
}
template <class T>
int SegmentTree<T>::leftChildIndex(const int parent) {
  return parent * 2 + 1;
}
template <class T>
int SegmentTree<T>::rightChildIndex(const int parent) {
  return parent * 2 + 2;
}
template <class T>
int SegmentTree<T>::parent(const int child) {
  return (child - 1) / 2;
}
template <class T>
int SegmentTree<T>::leaf(const int index) {
  return index + leafNum - 1;
}
template <class T>
T SegmentTree<T>::find(const int l, const int r) {
  return query(l, r, 0, 0, leafNum);
}
template <class T>
T SegmentTree<T>::query(const int l, const int r, const int node, const int al,
                        const int ar) {
  if (r <= al || ar <= l) return id;
  if (l <= al && ar <= r) return data[node];
  int mid = (al + ar) / 2;
  T leftValue = query(l, r, leftChildIndex(node), al, mid);
  T rightValue = query(l, r, rightChildIndex(node), mid, ar);
  return op(leftValue, rightValue);
}
template <class T>
void SegmentTree<T>::update(const int index, const T value) {
  int i = leaf(index);
  data[i] = updateOp(data[i], value);
  while (i > 0) {
    i = parent(i);
    data[i] = op(data[rightChildIndex(i)], data[leftChildIndex(i)]);
  }
}
int main() {
  long long int n, m;
  cin >> n >> m;
  priority_queue<
      pair<long long int, pair<long long int, long long int>>,
      vector<pair<long long int, pair<long long int, long long int>>>,
      greater<pair<long long int, pair<long long int, long long int>>>>
      lrc, clr;
  for (int i = 0; i < m; i++) {
    long long int l, r, c;
    cin >> l >> r >> c;
    l--;
    r--;
    lrc.push(make_pair(l, make_pair(r, c)));
  }
  while (!lrc.empty()) {
    auto p = lrc.top();
    if (p.first == 0LL) {
      clr.push(make_pair(p.second.second, make_pair(p.first, p.second.first)));
      lrc.pop();
    } else {
      break;
    }
  }
  SegmentTree<long long int> seg(
      n, (1LL << 51),
      [](long long int a, long long int b) -> long long int {
        return min(a, b);
      },
      [](long long int a, long long int b) -> long long int {
        return min(a, b);
      });
  seg.update(0, 0);
  while (!clr.empty()) {
    auto p = clr.top();
    clr.pop();
    long long int l = p.second.first, r = p.second.second, c = p.first;
    auto mi = seg.find(l, r) + c;
    seg.update(r, mi);
    while (!lrc.empty()) {
      auto q = lrc.top();
      if (q.first <= r) {
        clr.push(
            make_pair(q.second.second, make_pair(q.first, q.second.first)));
        lrc.pop();
      } else {
        break;
      }
    }
  }
  if (seg.find(n - 1, n) == (1LL << 51)) {
    cout << -1 << endl;
  } else {
    cout << seg.find(n - 1, n) << endl;
  }
}
