output_description: Print the length of the shortest path from Vertex 1 to Vertex N in the final
  graph. If there is no shortest path, print `-1` instead.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      L_1 R_1 C_1
      :
      L_M R_M C_M
attempt: # from collections import Counter,defaultdict,deque
  import sys
  
  # import bisect
  # import math
  # import itertools
  # import string
  import queue
  
  # import copy
  from heapq import heappop, heappush
  
  input = sys.stdin.readline
  sys.setrecursionlimit(10**8)
  mod = 10**9 + 7
  
  
  def inp():  # n=1
      return int(input())
  
  
  def inpm():  # x=1,y=2
      return map(int, input().split())
  
  
  def inpl():  # a=[1,2,3,4,5,...,n]
      return list(map(int, input().split()))
  
  
  def inpls():  # a=['1','2','3',...,'n']
      return list(input().split())
  
  
  def inplm(n):  # x=[] 複数行
      return list(int(input()) for _ in range(n))
  
  
  def inpll(n):  # [[1,1,1,1],[2,2,2,2],[3,3,3,3]]
      return sorted([list(map(int, input().split())) for _ in range(n)])
  
  
  def sortx(x, n, k):
      if k == 0:
          x.sort(key=lambda y: y[1, n])
      else:
          x.sort(reversed=True, key=lambda y: y[1, n])
  
  
  def graph():
      n = inp()
      g = [[] for _ in range(n)]
      for i in range(n):
          a = inp()
          a -= 1
          g[i].append(a)
          g[a].append(i)
      return n, g
  
  
  def graphm():
      n, m = inpm()
      g = [[] for _ in range(n)]
      for _ in range(m):
          a, b, w = inpm()
          a -= 1
          b -= 1
          g[a].append((b, w))
          g[b].append((a, w))
      return n, m, g
  
  
  def dijkstra(s, n, g):  # sからの最短距離 頂点数n
      s -= 1
      que = queue.Queue()
      d = [10**15 for _ in range(n)]
      d[s] = 0
      que.put((0, s))
      while not que.empty():
          p = que.get()
          v = p[1]
          if d[v] < p[0]:
              continue
          for i in range(len(g[v])):
              edge = g[v][i]
              if d[edge[0]] > d[v] + edge[1]:
                  d[edge[0]] = d[v] + edge[1]
                  que.put((d[edge[0]], edge[0]))
      return d
  
  
  def dijkstra1(s, n, g):  # sからの最短距離 頂点数n
      s -= 1
      que = []
      d = [10**15 for _ in range(n)]
      d[s] = 0
      heappush(que, (0, s))
      while len(que) > 0:
          p = heappop(que)
          v = p[1]
          if d[v] < p[0]:
              continue
          for i in range(len(g[v])):
              edge = g[v][i]
              if d[edge[0]] > d[v] + edge[1]:
                  d[edge[0]] = d[v] + edge[1]
                  heappush(que, (d[edge[0]], edge[0]))
      return d
  
  
  def main():
      n, m, g = graphm()
      s = 1
      for i in range(n - 1):
          a = i + 1
          b = i
          g[a].append((b, 0))
  
      dis = dijkstra1(s, n, g)
      if dis[n - 1] == 10**15:
          print(-1)
      else:
          print(dis[n - 1])
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  We have N points numbered 1 to N arranged in a line in this order.
  
  Takahashi decides to make an undirected graph, using these points as the
  vertices. In the beginning, the graph has no edge. Takahashi will do M
  operations to add edges in this graph. The i-th operation is as follows:
  
    * The operation uses integers L_i and R_i between 1 and N (inclusive), and a positive integer C_i. For every pair of integers (s, t) such that L_i \leq s < t \leq R_i, add an edge of length C_i between Vertex s and Vertex t.
  
  The integers L_1, ..., L_M, R_1, ..., R_M, C_1, ..., C_M are all given as
  input.
  
  Takahashi wants to solve the shortest path problem in the final graph
  obtained. Find the length of the shortest path from Vertex 1 to Vertex N in
  the final graph.
samples: [{"input": "4 3\n    1 3 2\n    2 4 3\n    1 4 6", "output": "5\n    \n\nWe have an edge of length 2 between Vertex 1 and Vertex 2, and an edge of\nlength 3 between Vertex 2 and Vertex 4, so there is a path of length 5 between\nVertex 1 and Vertex 4.\n\n* * *"}, {"input": "4 2\n    1 2 1\n    3 4 2", "output": "-1\n    \n\n* * *"}, {"input": "10 7\n    1 5 18\n    3 4 8\n    1 3 5\n    4 7 10\n    5 9 8\n    6 10 5\n    8 10 3", "output": "28"}]