Iahub got lost in a very big desert. The desert can be represented as a *n* × *n* square matrix, where each cell is a zone of the desert. The cell (*i*, *j*) represents the cell at row *i* and column *j* (1 ≤ *i*, *j* ≤ *n*). Iahub can go from one cell (*i*, *j*) only down or right, that is to cells (*i* + 1, *j*) or (*i*, *j* + 1). 

Also, there are *m* cells that are occupied by volcanoes, which Iahub cannot enter. 

Iahub is initially at cell (1, 1) and he needs to travel to cell (*n*, *n*). Knowing that Iahub needs 1 second to travel from one cell to another, find the minimum time in which he can arrive in cell (*n*, *n*).
The first line contains two integers *n* (1 ≤ *n* ≤ 10<sup class="upper-index">9</sup>) and *m* (1 ≤ *m* ≤ 10<sup class="upper-index">5</sup>). Each of the next *m* lines contains a pair of integers, *x* and *y* (1 ≤ *x*, *y* ≤ *n*), representing the coordinates of the volcanoes.

Consider matrix rows are numbered from 1 to *n* from top to bottom, and matrix columns are numbered from 1 to *n* from left to right. There is no volcano in cell (1, 1). No two volcanoes occupy the same location.
from collections import defaultdict

def f(u, v):
    s, n = [], len(v)
    i = j = 0
    for i in range(len(u)):
        while v[j][1] <= u[i][0]:
            j += 1
            if j == n: return s
        if u[i][1] <= v[j][0]: continue
        if u[i][0] >= v[j][0]: s.append(u[i])
        else: s.append((v[i][0], u[j][1]))
    return s

n, m = map(int, input().split())
p = defaultdict(list)

for i in range(m):
    x, y = map(int, input().split())
    p[x].append(y)

for x in p:
    if len(p[x]) > 1:
        p[x].sort()
    t, i = [], 1
    for j in p[x]:
        if i != j: t.append((i, j))
        i = j + 1
    if i != n + 1: t.append((i, n + 1))
    p[x] = t

k, s = 1, [(1, 2)]
for x in sorted(p.keys()):
    if x == k:
        s = f(p[x], s)
        if not s: break
    else: s = [(s[0][0], n + 1)]
    k = x + 1

if s and k == n + 1 and s[-1][1] != k: s = []
print(2 * (n - 1) if s else -1)