# 뱀과 사다리 게임

import sys
from collections import deque

input = sys.stdin.readline

def solution():
    n, m = map(int, input().rstrip().split())
    g = [-1] * 101
    visited = [-1] * 101
    for _ in range(n+m):
        v, w = map(int, input().rstrip().split())
        g[v] = w
    
    q = deque([1])
    visited[1] = 0
    while q:
        now = q.popleft()
        for k in range(1, 7):
            nxt = now+k
            if nxt > 100:
                continue

            if g[nxt] != -1:
                nxt = g[nxt]

            if visited[nxt] == -1:
                q.append(nxt)
                visited[nxt] = visited[now]+1

    print(visited[100])
    return

solution()

"""
걸린 시간: 몰라

시간 복잡도: 각 칸당 한번씩만 방문하기 때문에 O(100)이다.

해설: 1697-s1과 같은 실수를 반복했다. 앞 뒤로 갈 수 있는 것은 dp로 할때 어디부터 채워야할지 모르기 때문에 bfs로 해야했거늘..
현재 칸에서 주사위를 굴려서 6칸을 다 갈 수 있고, 이때 사다리나 뱀이 있으면 그곳으로 바로 이동해야 한다.
근데 나는 일단 6칸을 다 방문처리하고, now에서 사다리나 뱀이 있으면 방문하는 방식으로 진행을 했다.
하지만 이렇게 하면 사다리를 타고 올라가는 곳이 레벨이 1이라고 할때, 주사위로 가서 한 번 더 간 칸, 즉 레벨 2의 칸이 큐에 먼저 들어간다.
레벨이 꼬여버리기 때문에 주사위로 온 칸이 사다리가 연결되어 있다면 바로 이동해서 그 칸을 큐에 넣는 것이 순서가 맞다.
주사위로 나온 칸은 그럼 계속 방문처리가 안되는 것 아니냐라고 생각할 수 있지만, 실제로 방문처리가 안되기도 하고
그 칸은 항상 사다리로 이동한 칸과 같은 취급을 받기 때문에 상관없다.
이렇게 최단거리 문제를 bfs로 풀때는 레벨을 잘 따져야 할 것 같다.
"""

# def dp_up(dp, g): # 30분
#     for i in range(2, 7):
#         for j in range(i-1, 0, -1):
#             dp[i] = min(dp[i], dp[j]+1)
#         dp[i] = min(dp[i], dp[g[i]] if g[i] != -1 else float('inf'))
        

#     for i in range(7, 101):
#         dp[i] = min(dp[i-1]+1, dp[i-2]+1, dp[i-3]+1, dp[i-4]+1, dp[i-5]+1, dp[i-6]+1, dp[g[i]] if g[i] != -1 else float('inf'))
    
#     return

# def dp_down(dp, g):
#     for i in range(100, 1, -1):
#         dp[i] = min(dp[i-1]+1, dp[i-2]+1, dp[i-3]+1, dp[i-4]+1, dp[i-5]+1, dp[i-6]+1, dp[g[i]] if g[i] != -1 else float('inf'))

#     return

# def solution():
#     n, m = map(int, input().rstrip().split())
#     g = [-1] * 101
#     dp = [float('inf')] * 101
#     dp[1] = 0

#     for _ in range(n+m):
#         v, w = map(int, input().rstrip().split())
#         g[w] = v # 도착점이 key, 시작점이 value
    
#     dp_up(dp, g)
#     dp_down(dp, g)
#     dp_up(dp, g)
#     print(dp[100])
#     # print(dp)
#     # print("70:", dp[70], "72:", dp[72], "67:", dp[67], "68:", dp[68], "98:", dp[98])

# solution()