Problem: 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.

Constraints

* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq L_i < R_i \leq N
* 1 \leq C_i \leq 10^9

Input

Input is given from Standard Input in the following format:


N M
L_1 R_1 C_1
:
L_M R_M C_M


Output

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.

Examples

Input

4 3
1 3 2
2 4 3
1 4 6


Output

5


Input

4 2
1 2 1
3 4 2


Output

-1


Input

10 7
1 5 18
3 4 8
1 3 5
4 7 10
5 9 8
6 10 5
8 10 3


Output

28

Solution (in JAVA):

Solution:
import java.util.Arrays;
import java.util.Scanner;

/**
 * Counting of Trees
 */
public class Main {

    public static void main(String[] args) throws Exception {
        try (Scanner sc = new Scanner(System.in)) {
            int N = sc.nextInt();
            int M = sc.nextInt();

            LRC[] lrcs = new LRC[M];
            for (int i = 0; i < M; i++) {
                LRC lrc = new LRC();
                lrc.L = sc.nextInt() - 1;
                lrc.R = sc.nextInt() - 1;
                lrc.C = sc.nextLong();
                lrcs[i] = lrc;
            }

            Arrays.sort(lrcs, (o1, o2) -> {
                int compare = Integer.compare(o1.L, o2.L);
                if (compare != 0) {
                    return compare;
                }
                return Long.compare(o1.C, o2.C);
            });

            long[] d = new long[N];
            for (int i = 1; i < N; i++) {
                d[i] = Long.MAX_VALUE;
            }

//            int L = -1;
//            int R = -1;
            for (int i=0;i<M;i++) {
                if (d[lrcs[i].L] == Long.MAX_VALUE) {
                    break;
                }

//                int t = lrcs[i].L + 1;
//                if (L == lrcs[i].L) {
//                    if (R >= lrcs[i].R) {
//                        continue;
//                    }
//                    t = R + 1;
//                }

                for (int j = lrcs[i].R; j >= lrcs[i].L + 1; j--) {
                    if (d[j] < d[lrcs[i].L] + lrcs[i].C) {
                        break;
                    }
                    d[j] = d[lrcs[i].L] + lrcs[i].C;
                }

//                L = lrcs[i].L;
//                R = lrcs[i].R;
            }

            long ans = d[N - 1];
            if (ans == Long.MAX_VALUE) {
                ans = -1;
            }

            System.out.println(ans);
        }
    }

    static class LRC {

        int L;

        int R;

        long C;

    }

}