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

Difficulty: UNKNOWN_DIFFICULTY

Solutions:
import heapq
import sys
(N, M) = map(int, input().split())
edges = []
for _ in range(M):
	(l, r, c) = map(int, input().split())
	edges.append((l - 1, r - 1, c))
edges.sort(reverse=True)
dp = [0] * N
que = [(0, 0)]
for i in range(1, N):
	while len(edges) > 0 and edges[-1][0] == i - 1:
		e = edges.pop()
		heapq.heappush(que, (dp[i - 1] + e[2], e[1]))
	while True:
		if len(que) == 0:
			print(-1)
			sys.exit()
		e = heapq.heappop(que)
		if e[1] >= i:
			dp[i] = e[0]
			heapq.heappush(que, e)
			break
print(dp[-1])


import sys
import heapq
input = sys.stdin.readline
(heapify, push, pop) = (heapq.heapify, heapq.heappush, heapq.heappop)
(_n, _m) = map(int, input().split())
_lrc = []
for _ in range(_m):
	(l, r, c) = map(int, input().split())
	_lrc.append((l - 1, r - 1, c))
_lrc.sort()

def chker(n, m, lrc):
	dst = [float('inf')] * n
	dst[0] = 0
	q = [(0, 0)]
	cnt = 0
	for i in range(n):
		while q:
			(d, r) = q[0]
			if i <= r:
				break
			pop(q)
		else:
			print(-1)
			return
		dst[i] = d
		while cnt < m and lrc[cnt][0] == i:
			(l, r, c) = lrc[cnt]
			push(q, (d + c, r))
			cnt += 1
	print(dst[-1])
chker(_n, _m, _lrc)


from heapq import heappop, heappush, heapify
import sys
input = lambda : sys.stdin.readline().rstrip()
inpl = lambda : list(map(int, input().split()))
(N, M) = inpl()
LRC = sorted([(lambda L, R, C: (L - 1, R - 1, C))(*inpl()) for _ in range(M)])
m = 0
dq = [(0, 0)]
for i in range(N):
	while dq and dq[0][1] < i:
		heappop(dq)
	if not dq:
		print(-1)
		break
	d = dq[0][0]
	while m < M and LRC[m][0] == i:
		heappush(dq, (d + LRC[m][2], LRC[m][1]))
		m += 1
else:
	print(d)


import heapq
(N, M) = map(int, input().split())
items = []
for _ in range(M):
	(l, r, c) = map(int, input().split())
	items.append([l, r, c])
items.sort()

def check():
	queue = []
	index = 0
	data = [None]
	dists = [None, 0]
	for i in range(1, N):
		while index < M:
			(l, r, c) = items[index]
			if l <= i:
				heapq.heappush(queue, (c + dists[i], -r))
				index += 1
			else:
				break
		while True:
			if len(queue) == 0:
				return None
			(c, r) = queue[0]
			if -r > i:
				break
			heapq.heappop(queue)
		data.append((c, -r))
		dists.append(c)
	return dists
data = check()
if data != None:
	print(data[N])
else:
	print(-1)


NN = 17
MI = [1 << 100] * ((1 << NN + 1) - 1)

def update(a, x):
	i = (1 << NN) - 1 + a
	MI[i] = min(MI[i], x)
	while True:
		i = (i - 1) // 2
		MI[i] = min(MI[2 * i + 1], MI[2 * i + 2])
		if i == 0:
			break

def rangemin(a):
	l = a + (1 << NN)
	r = (1 << NN + 1) - 2
	mi = 1 << 100
	while l < r:
		if l % 2:
			mi = min(mi, MI[l - 1])
			l += 1
		if r % 2:
			r -= 1
			mi = min(mi, MI[r - 1])
		l >>= 1
		r >>= 1
	return mi
(N, M) = map(int, input().split())
X = []
for _ in range(M):
	(l, r, c) = map(int, input().split())
	X.append((l, r, c))
X = sorted(X)
update(1, 0)
for (l, r, c) in X:
	mi = rangemin(l)
	update(r, mi + c)
ans = MI[(1 << NN) - 1 + N]
print(ans if ans < 1 << 100 else -1)


from heapq import heapify, heappush, heappop
import sys
input = sys.stdin.readline
INF = float('inf')

def solve():
	(N, M) = map(int, input().split())
	Es = []
	for _ in range(M):
		(L, R, C) = map(int, input().split())
		(L, R) = (L - 1, R - 1)
		Es.append((L, R, C))
	Es.sort()
	PQ = [(0, 0)]
	dists = [INF] * N
	iE = 0
	for tm in range(N):
		while PQ:
			(dist, R) = PQ[0]
			if tm <= R:
				break
			heappop(PQ)
		else:
			return -1
		dists[tm] = dist
		while iE < M and Es[iE][0] == tm:
			(L, R, C) = Es[iE]
			heappush(PQ, (dist + C, R))
			iE += 1
	return dists[-1]
print(solve())


import sys

def input():
	return sys.stdin.readline().strip()
(N, M) = list(map(int, input().split()))
LRC = []
for _ in range(M):
	LRC.append(tuple(map(int, input().split())))
LRC.sort()

class seg_tree:

	def __init__(self, N):
		self.N0 = 2 ** (N - 1).bit_length()
		self.INF = 2 ** 100 - 1
		self.data = [self.INF] * (2 * self.N0)

	def update(self, k, x):
		k += self.N0 - 1
		self.data[k] = x
		while k >= 0:
			k = (k - 1) // 2
			self.data[k] = min(self.data[2 * k + 1], self.data[2 * k + 2])

	def query(self, l, r):
		L = l + self.N0
		R = r + self.N0
		s = self.INF
		while L < R:
			if R & 1:
				R -= 1
				s = min(s, self.data[R - 1])
			if L & 1:
				s = min(s, self.data[L - 1])
				L += 1
			L >>= 1
			R >>= 1
		return s
dist = seg_tree(N)
dist.update(0, 0)
for i in range(M):
	(L, R, C) = LRC[i]
	L -= 1
	R -= 1
	dist_start = dist.query(L, N)
	target_dist = dist.query(R, N)
	if dist_start + C < target_dist:
		dist.update(R, dist_start + C)
ans = dist.query(N - 1, N)
if ans == dist.INF:
	print(-1)
else:
	print(ans)


import sys
input = sys.stdin.readline
import heapq
(n, m) = map(int, input().split())
D = [0]
P = []
ans = float('inf')
for i in range(m):
	(l, r, c) = map(int, input().split())
	P.append((l, r, c))
P.sort(key=lambda x: x[0])
heapq.heappush(D, 0 * 10 ** 15 + 1)
for (l, r, c) in P:
	while D:
		ld = heapq.heappop(D)
		dd = ld // 10 ** 15
		ll = ld % 10 ** 15
		if ll < l:
			continue
		else:
			break
	if ll >= l:
		heapq.heappush(D, r + (dd + c) * 10 ** 15)
	heapq.heappush(D, ll + dd * 10 ** 15)
while D:
	ld = heapq.heappop(D)
	dd = ld // 10 ** 15
	ll = ld % 10 ** 15
	if ll == n:
		ans = min(ans, dd)
print(-1 if ans == float('inf') else ans)


import sys
from collections import defaultdict
from operator import itemgetter
from heapq import heappop, heappush

def inpl():
	return list(map(int, input().split()))
(N, M) = inpl()
D = [0] + [10 ** 18] * (N - 1)
g0 = itemgetter(0)
Q = sorted([inpl() for _ in range(M)], key=g0, reverse=True)
HQ = [(0, 0), (10 ** 18, N)]
for i in range(N):
	while HQ[0][1] < i:
		heappop(HQ)
	v = HQ[0][0]
	while len(Q) and i == Q[-1][0] - 1:
		(l, r, c) = Q.pop()
		heappush(HQ, (v + c, r - 1))
if v == 10 ** 18:
	print(-1)
else:
	print(v)