1 1 1 2
5
1000000000 1 10000
19920401 1188 5566
1000000000 1 10000
1 1 10000
5 100 200
 6 15 7 15
9
6 15 15
7 14 14
6 15 15
9 14 14
7 14 16
6 15 15
6 15 15
7 14 14
8 15 15
 1 1 1000000000 2
5
1000000000 1 10000
19920401 1188 5566
1000000000 1 10000
1 1 10000
5 100 200
 89 29 88 30
16
87 31 31
14 95 95
98 88 89
96 88 88
14 97 97
13 97 98
100 88 88
88 32 32
99 88 89
90 29 29
87 31 31
15 94 96
89 29 29
88 32 32
97 89 89
88 29 30
 30 14 39 19
31
35 7 11
37 11 12
32 13 13
37 5 6
46 13 13
37 14 14
31 13 13
43 13 19
45 15 19
46 13 13
32 17 17
41 14 19
30 14 14
43 13 17
34 16 18
44 11 19
38 13 13
40 12 20
37 16 18
46 16 18
34 10 14
36 9 10
36 15 19
38 15 19
42 13 19
33 14 15
35 15 19
33 17 18
39 12 20
36 5 7
45 12 12
 9 8 7 8
9
10 6 6
10 6 6
7 7 8
9 5 6
8 9 9
9 5 5
9 8 8
8 5 6
9 10 10
 2 1 1 1
2
1 1 2
2 1 2
 13 16 20 10
18
13 16 16
20 10 10
19 10 10
12 15 15
20 10 10
18 11 11
19 10 10
19 10 10
20 10 10
19 10 10
20 10 10
20 10 10
19 10 10
18 11 11
13 16 16
12 15 15
19 10 10
19 10 10

1
 1
 -1
 1
 9
 2
 1
 -1

from collections import deque, defaultdict


class Solution:

    def solve(self):
        kpos = input().split()
        kpos = [int(x) for x in kpos]
        startK = [kpos[0], kpos[1]]
        endK = [kpos[2], kpos[3]]
        N = int(input())

        intervals_dict = defaultdict(list)
        for _ in range(N):
            allowed = input().split()
            allowed = [int(x) for x in allowed]
            row, start, end = allowed
            intervals_dict[row].append([start, end])

        # merge intervals
        for row in intervals_dict:
            intervals = intervals_dict[row]
            intervals.sort()
            final_merged = []

            last_start, last_end = intervals[0]
            for interval in intervals[1:]:
                start, end = interval
                if start <= last_end:
                    last_end = end
                    continue
                final_merged.append([last_start, last_end])
                last_start = start
                last_end = end

            final_merged.append([last_start, last_end])
            last_start = start
            intervals_dict[row] = final_merged

        # BFS
        queue = deque([startK])
        moves = 0
        seen = set((startK[0], startK[1]))
        directions = [(i, j) for i in [1, 0, -1]
                      for j in [1, 0, -1] if not(i == j == 0)]

        def get_intervals(intervals_dict):
            for intervals in intervals_dict:
                yield intervals

        while queue:
            moves += 1
            for i in range(len(queue)):
                x, y = queue.popleft()

                for dx, dy in directions:
                    row, col = x + dx, y + dy

                    if row in intervals_dict and (row, col) not in seen:
                        valid = False
                        for interval in intervals_dict[row]:
                            start_int, end_int = interval
                            if start_int <= col <= end_int:
                                valid = True
                                break
                        if valid:
                            intervals_dict[row][0][0] <= col <= intervals_dict[row][0][1]
                            seen.add((row, col))
                            if (row, col) == (endK[0], endK[1]):
                                return moves
                            queue.append((row, col))

        return -1


soln = Solution()
print(soln.solve())

		 	 					  	  	   	 	 	 	 	 	