import sys
import re
import heapq

# グラフの初期化
def initialize_graph():
    graph = {}
    n, edge_list = read_file()
    for edge_inf in edge_list:
        node1 = edge_inf[0]
        node2 = edge_inf[1]
        cost = edge_inf[2]
        # ノードの設定と無向エッジのコスト設定
        graph = set_new_node(graph, node1, node2)
        graph[node1][node2] = cost
        graph[node2][node1] = cost
    return n, graph

def set_new_node(graph, node1, node2):
    if not node1 in graph.keys():
        graph[node1] = {}
    if not node2 in graph.keys():
        graph[node2] = {}
    return graph

# ダイクストラ法によって最短経路問題を解く
def solve_by_dijkstra(graph, n):
    # ノード毎のSTARTからの最小コスト
    min_dist_dict = {}
    # ノードに最小コストで辿り着く場合の直前のノード
    prev_node_dict = {}
    q = []
    heapq.heappush(q, (0, 1))
    
    prev_node = ''

    while True:
        # 確定したノードから遷移可能なノードのうち
        # 最小のコストと遷移先ノードをmin_dist_dictとprev_node_dictに設定
        if q == []:
            return None, None
        dist, node = heapq.heappop(q)
        min_dist_dict[node] = dist
        prev_node_dict[node] = prev_node
        # もしGOALノードの最小コストが確定したらループを抜ける
        if node == n: 
            return min_dist_dict, prev_node_dict
        prev_node = node
        # 確定したノードから遷移可能なノードについて
        # コストを計算し，キュー(q)に追加する
        culc_min_dist_and_put(graph, q, node, min_dist_dict, prev_node_dict)
    return None, None

def culc_min_dist_and_put(graph, q, departure_node, min_dist_dict, prev_node_dict):
    # 直前に確定したノードから遷移可能なすべてのノードについて繰り返し
    for arrival_node in graph[departure_node].keys():
        # 遷移可能なノードについて，直前に確定したノードから遷移した場合のコストを計算
        tmp_d = min_dist_dict[departure_node] + graph[departure_node][arrival_node]
        # 過去に遷移先ノードの最小コストを計算済みかどうか
        if arrival_node in min_dist_dict.keys():
            # 過去に計算していたSTARTからの最小コストより直前に確定したノードから遷移した場合の
            # コストが小さかった場合，最小コストを更新
            if tmp_d < min_dist_dict[arrival_node]:
                min_dist_dict[arrival_node] = tmp_d
                heapq.heappush(q, (min_dist_dict[arrival_node], arrival_node))
        else:
            min_dist_dict[arrival_node] = tmp_d
            heapq.heappush(q, (min_dist_dict[arrival_node], arrival_node))

def main():
    n, graph = initialize_graph()
    out = -1
    #jmin_dist_dict, prev_node_dict = solve_by_dijkstra(graph, n)
    #jif min_dist_dict is not None:
    #j    out = min_dist_dict[n]
    #jelse:
    #j    out = -1
    print(out)

def read_file():
    #file_name = 'edge_inf.csv'
    #edge_list = []
    #with open(file_name,'r',encoding='utf-8') as fin:
    #    for line in fin.readlines():
    #        edge_list.append(re.sub(r'[\r\n]','',line))

    M = 10 ** 10
    n, m = map(int, input().split(" "))
    ws = [[M for _ in range(n+1)] for _ in range(n+1)]

    pairs = []
    for _ in range(m):
        l, r, w = map(int, input().split(" "))
        #print("i", _, l, r, w)
        for s in range(l, r+1):
            for t in range(s+1, r+1):
                #print((s, t))
                ws[s][t] = min(ws[s][t], w)
                pairs.append((s, t))

    set_pairs = set(pairs)
    #print(pairs, set_pairs)
    edge_list = []
    for s, t in set_pairs:
        w = ws[s][t]
        edge_list.append([s, t, w])

    #print("edge_list", edge_list)
    return n, edge_list


if __name__ == '__main__':
    main()
    sys.exit(0)