using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using static MyIO;

public struct Edge
{
	public int To;
	public long Cost;

	public Edge(int to, long cost)
	{
		To = to;
		Cost = cost;
	}
}

public class D
{
	public static void Main() => (new Solver()).Solve();
}

public class Solver
{
	public void Solve()
	{
		int N = GetInt();
		int M = GetInt();
		int[] L = new int[M];
		int[] R = new int[M];
		long[] C = new long[M];
		for(int i = 0; i < M; i++)
		{
			L[i] = GetInt() - 1;
			R[i] = GetInt() - 1;
			C[i] = GetLong();
		}

		var adj = Enumerable.Range(0, N).Select(_ => new List<Edge>()).ToArray();
		for(int i = 0; i < N - 1; i++)
			adj[i + 1].Add(new Edge(i, 0));

		for(int i = 0; i < M; i++)
			adj[L[i]].Add(new Edge(R[i], C[i]));

		long[] d = dijkstra(adj, 0);
		if(d[N - 1] == long.MaxValue / 2)
			Console.WriteLine(-1);
		else
			Console.WriteLine(d[N - 1]);
	}

	private long[] dijkstra(List<Edge>[] adj, int s)
	{
		Comparison<Tuple<long, int>> comp = ((x, y) => x.Item1.CompareTo(y.Item1));
		var pq = new PriorityQueue<Tuple<long, int>>(adj.Length, comp);

		long[] d = Enumerable.Repeat(long.MaxValue / 2, adj.Length).ToArray();
		d[s] = 0;
		pq.Push(Tuple.Create(0L, s));
		while(pq.Size > 0)
		{
			var p = pq.Pop();
			int v = p.Item2;
			if(d[v] < p.Item1)
				continue;
			for(int i = 0; i < adj[v].Count; i++)
			{
				var edge = adj[v][i];
				if(d[edge.To] > d[v] + edge.Cost)
				{
					d[edge.To] = d[v] + edge.Cost;
					pq.Push(Tuple.Create(d[edge.To], edge.To));
				}
			}
		}

		return d;
	}

	private void chmin(ref long x, long y) => x = Math.Min(x, y);
}

public class PriorityQueue<T>
{
	public long Size { get; private set; } = 0;
	public long MaxSize { get; private set; } = 0;
	private T[] m_heap;
	private Comparison<T> Comp = null;
	
	public PriorityQueue(long maxSize, Comparison<T> comp)
	{
		if(maxSize <= 0)
			throw new Exception();
		MaxSize = maxSize;
		m_heap = new T[maxSize];

		Comp = comp;
	}
	
	public void Push(T x)
	{
		if(Size == MaxSize)
		{
			T[] new_heap = new T[MaxSize << 1];
			Array.Copy(m_heap, new_heap, MaxSize);
			m_heap = new_heap;
			MaxSize <<= 1;
		}
		
		long i = Size++;
		while(i > 0)
		{
			long p = (i - 1)/2;
			if(Comp(m_heap[p], x) <= 0)
				break;
			m_heap[i] = m_heap[p];
			i = p;			
		}
		m_heap[i] = x;		
	}
	
	public T Pop()
	{
		if(Size == 0)
			throw new Exception("Queue is empty.");
		
		T result = m_heap[0];
		T x = m_heap[--Size];
		long i = 0;
		while(i * 2 + 1 < Size)
		{
			long c1 = i * 2 + 1, c2 = i * 2 + 2;
			if(c2 < Size && Comp(m_heap[c2], m_heap[c1]) < 0)
				c1 = c2;
			if(Comp(m_heap[c1], x) >= 0)
				break;
			m_heap[i] = m_heap[c1];
			i = c1;
		}
		m_heap[i] = x;
		
		return result;		
	}	
}

public static class MyIO
{
	private static string[] args = null;
	private static int num = -1;
	private static int used = -1;

	private static string getArg()
	{
		if(used == num)
		{
			args = Console.ReadLine().Split(' ');
			num = args.Length;
			used = 0;
		}
		return args[used++];
	}

	public static int GetInt() => int.Parse(getArg());
	public static long GetLong() => long.Parse(getArg());
	public static double GetDouble() => double.Parse(getArg());
	public static string GetString() => getArg();
	public static char GetChar() => getArg()[0];
	public static int[] GetInts(int N) => Enumerable.Range(0, N).Select(_ => GetInt()).ToArray();
	public static long[] GetLongs(int N) => Enumerable.Range(0, N).Select(_ => GetLong()).ToArray();
	public static double[] GetDoubles(int N) => Enumerable.Range(0, N).Select(_ => GetDouble()).ToArray();
	public static string[] GetStrings(int N) => Enumerable.Range(0, N).Select(_ => GetString()).ToArray();
}


Measured memory_bytes: 39912