from collections import defaultdict

from heapq import heappop, heappush





class Graph():



    def __init__(self):

        self.graph = defaultdict(list)



    def __len__(self):

        return len(self.graph)



    def add_edge(self, src, dst, weight=1):

        self.graph[src].append((dst, weight))



    def get_nodes(self):

        return list(self.graph.keys())





class Dijkstra():



    def __init__(self, graph, start):

        self.g = graph.graph



        self.dist = defaultdict(lambda: float("inf"))

        self.dist[start] = 0



        self.prev = defaultdict(lambda: None)



        self.Q = []

        heappush(self.Q, (self.dist[start], start))



        while self.Q:

            dist_u, u = heappop(self.Q)



            if self.dist[u] < dist_u:

                continue



            for v, weight in self.g[u]:

                alt = dist_u + weight

                if self.dist[v] > alt:

                    self.dist[v] = alt

                    self.prev[v] = u

                    heappush(self.Q, (alt, v))



    def shortest_distance(self, goal):



        return self.dist[goal]



    def shortest_path(self, goal):

        path = []

        node = goal



        while node is not None:

            path.append(node)

            node = self.prev[node]



        return path[::-1]





import sys

input=sys.stdin.readline

n,m=list(map(int,input().split()))

g=Graph()



for _ in range(m):

    l,r,c=list(map(int,input().split()))

    g.add_edge(l,r,c)

for i in range(2,n+1):

    g.add_edge(i,i-1,0)





d = Dijkstra(g,1)

ans=d.shortest_distance(n)

print((ans if ans!=float("inf") else -1))

# -*- coding: utf-8 -*-

import bisect

import heapq

import math

import random

import sys

from collections import Counter, defaultdict, deque

from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal

from functools import lru_cache, reduce

from itertools import combinations, combinations_with_replacement, product, permutations

from operator import add, mul, sub



sys.setrecursionlimit(100000)

input = sys.stdin.readline

INF = 2**62-1



def read_int():

    return int(input())





def read_int_n():

    return list(map(int, input().split()))





def read_float():

    return float(input())





def read_float_n():

    return list(map(float, input().split()))





def read_str():

    return input().strip()





def read_str_n():

    return list(map(str, input().split()))





def error_print(*args):

    print(*args, file=sys.stderr)





def mt(f):

    import time



    def wrap(*args, **kwargs):

        s = time.time()

        ret = f(*args, **kwargs)

        e = time.time()



        error_print(e - s, 'sec')

        return ret



    return wrap





def Dijkstra(g, s):

    prev = {}

    q = []

    d = defaultdict(lambda: INF)

    d[s] = 0

    heapq.heappush(q, (d[s], s))



    while q:

        c, u = heapq.heappop(q)

        if d[u] < c:

            continue

        for v, w in g[u].items():

            alt = w + c

            if d[v] > alt:

                d[v] = alt

                prev[v] = u

                heapq.heappush(q, (alt, v))

    return d



@mt

def slv(N, LRC):

    g = defaultdict(dict)



    LRC.sort(key=lambda x: x[2], reverse=True )

    for l, r, c in LRC:

        g[l][r] = c

    

    for i in range(2, N+1):

        g[i][i-1] = 0



    

    d = Dijkstra(g, 1)



    return -1 if d[N] == INF else d[N]





def main():

    N, M = read_int_n()

    LRC = [read_int_n() for _ in range(M)]

    print(slv(N, LRC))



if __name__ == '__main__':

    main()

from collections import defaultdict
from heapq import heappop, heappush


class Graph:
    def __init__(self):
        self.graph = defaultdict(list)

    def __len__(self):
        return len(self.graph)

    def add_edge(self, src, dst, weight=1):
        self.graph[src].append((dst, weight))

    def get_nodes(self):
        return list(self.graph.keys())


class Dijkstra:
    def __init__(self, graph, start):
        self.g = graph.graph
        self.dist = defaultdict(lambda: float("inf"))
        self.dist[start] = 0
        self.prev = defaultdict(lambda: None)
        self.Q = []
        heappush(self.Q, (self.dist[start], start))
        while self.Q:
            dist_u, u = heappop(self.Q)
            if self.dist[u] < dist_u:
                continue
            for v, weight in self.g[u]:
                alt = dist_u + weight
                if self.dist[v] > alt:
                    self.dist[v] = alt
                    self.prev[v] = u
                    heappush(self.Q, (alt, v))

    def shortest_distance(self, goal):
        return self.dist[goal]

    def shortest_path(self, goal):
        path = []
        node = goal
        while node is not None:
            path.append(node)
            node = self.prev[node]
        return path[::-1]


import sys

input = sys.stdin.readline
n, m = list(map(int, input().split()))
g = Graph()
for _ in range(m):
    l, r, c = list(map(int, input().split()))
    g.add_edge(l, r, c)
for i in range(2, n + 1):
    g.add_edge(i, i - 1, 0)
d = Dijkstra(g, 1)
ans = d.shortest_distance(n)
print((ans if ans != float("inf") else -1))

# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62 - 1


def read_int():
    return int(input())


def read_int_n():
    return list(map(int, input().split()))


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, "sec")
        return ret

    return wrap


def Dijkstra(g, s):
    prev = {}
    q = []
    d = defaultdict(lambda: INF)
    d[s] = 0
    heapq.heappush(q, (d[s], s))
    while q:
        c, u = heapq.heappop(q)
        if d[u] < c:
            continue
        for v, w in g[u].items():
            alt = w + c
            if d[v] > alt:
                d[v] = alt
                prev[v] = u
                heapq.heappush(q, (alt, v))
    return d


@mt
def slv(N, LRC):
    g = defaultdict(dict)
    LRC.sort(key=lambda x: x[2], reverse=True)
    for l, r, c in LRC:
        g[l][r] = c
    for i in range(2, N + 1):
        g[i][i - 1] = 0
    d = Dijkstra(g, 1)
    return -1 if d[N] == INF else d[N]


def main():
    N, M = read_int_n()
    LRC = [read_int_n() for _ in range(M)]
    print(slv(N, LRC))


if __name__ == "__main__":
    main()

-from collections import defaultdict -from heapq import heappop, heappush +# -*- coding: utf-8 -*- +import bisect +import heapq +import math +import random +import sys +from collections import Counter, defaultdict, deque +from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal +from functools import lru_cache, reduce +from itertools import combinations, combinations_with_replacement, product, permutations +from operator import add, mul, sub + +sys.setrecursionlimit(100000) +input = sys.stdin.readline +INF = 2**62 - 1 -class Graph: -    def __init__(self): -        self.graph = defaultdict(list) - -    def __len__(self): -        return len(self.graph) - -    def add_edge(self, src, dst, weight=1): -        self.graph[src].append((dst, weight)) - -    def get_nodes(self): -        return list(self.graph.keys()) +def read_int(): +    return int(input()) -class Dijkstra: -    def __init__(self, graph, start): -        self.g = graph.graph -        self.dist = defaultdict(lambda: float("inf")) -        self.dist[start] = 0 -        self.prev = defaultdict(lambda: None) -        self.Q = [] -        heappush(self.Q, (self.dist[start], start)) -        while self.Q: -            dist_u, u = heappop(self.Q) -            if self.dist[u] < dist_u: -                continue -            for v, weight in self.g[u]: -                alt = dist_u + weight -                if self.dist[v] > alt: -                    self.dist[v] = alt -                    self.prev[v] = u -                    heappush(self.Q, (alt, v)) - -    def shortest_distance(self, goal): -        return self.dist[goal] - -    def shortest_path(self, goal): -        path = [] -        node = goal -        while node is not None: -            path.append(node) -            node = self.prev[node] -        return path[::-1] +def read_int_n(): +    return list(map(int, input().split())) -import sys +def read_float(): +    return float(input()) -input = sys.stdin.readline -n, m = list(map(int, input().split())) -g = Graph() -for _ in range(m): -    l, r, c = list(map(int, input().split())) -    g.add_edge(l, r, c) -for i in range(2, n + 1): -    g.add_edge(i, i - 1, 0) -d = Dijkstra(g, 1) -ans = d.shortest_distance(n) -print((ans if ans != float("inf") else -1)) + +def read_float_n(): +    return list(map(float, input().split())) + + +def read_str(): +    return input().strip() + + +def read_str_n(): +    return list(map(str, input().split())) + + +def error_print(*args): +    print(*args, file=sys.stderr) + + +def mt(f): +    import time + +    def wrap(*args, **kwargs): +        s = time.time() +        ret = f(*args, **kwargs) +        e = time.time() +        error_print(e - s, "sec") +        return ret + +    return wrap + + +def Dijkstra(g, s): +    prev = {} +    q = [] +    d = defaultdict(lambda: INF) +    d[s] = 0 +    heapq.heappush(q, (d[s], s)) +    while q: +        c, u = heapq.heappop(q) +        if d[u] < c: +            continue +        for v, w in g[u].items(): +            alt = w + c +            if d[v] > alt: +                d[v] = alt +                prev[v] = u +                heapq.heappush(q, (alt, v)) +    return d + + +@mt +def slv(N, LRC): +    g = defaultdict(dict) +    LRC.sort(key=lambda x: x[2], reverse=True) +    for l, r, c in LRC: +        g[l][r] = c +    for i in range(2, N + 1): +        g[i][i - 1] = 0 +    d = Dijkstra(g, 1) +    return -1 if d[N] == INF else d[N] + + +def main(): +    N, M = read_int_n() +    LRC = [read_int_n() for _ in range(M)] +    print(slv(N, LRC)) + + +if __name__ == "__main__": +    main()