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

  import java.util.*;

public class Main {
    public static Scanner scan = new Scanner(System.in);
    static class Point{
        int row;
        int column;

        public Point(int row, int column) {
            this.row = row;
            this.column = column;
        }
    }
    public static int row_points[]={0,1,0,-1,1,-1,1,-1};
    public static int col_points[] ={1,0,-1,0,1,-1,-1,1};
    public static int BFS(Point initial_point,Point final_point,Map<Integer,Set<Integer>>valid){
        Queue<Point> queue = new LinkedList<>();
        Map<Point,Integer> map = new HashMap<>();
        Map<Integer,Set<Integer>> visited = new HashMap<>();
        visited.put(initial_point.row,new HashSet<>());
        visited.get(initial_point.row).add(initial_point.column);
        queue.add(initial_point);
        map.put(initial_point,0);
        while (!queue.isEmpty()){
            Point point = queue.poll();
            for(int i=0;i<8;i++){
                int new_row = point.row + row_points[i];
                int new_col = point.column + col_points[i];
                Point new_Point = new Point(new_row,new_col);
                if(valid.containsKey(new_row) && valid.get(new_row).contains(new_col) && (!visited.containsKey(new_row)||
                        !visited.get(new_row).contains(new_col))){
                    if(new_row == final_point.row && new_col == final_point.column){
                        return map.get(point)+1;
                    }
                    queue.add(new_Point);
                    if(!visited.containsKey(new_row)){
                        visited.put(new_row,new HashSet<>());
                    }
                    visited.get(new_row).add(new_col);
                    map.put(new_Point,map.get(point)+1);
                }
            }
        }
        return -1;
    }
    public static void KingPath(){
        int initial_row = scan.nextInt();
        int initial_col = scan.nextInt();
        Point inital_point = new Point(initial_row,initial_col);
        int final_row = scan.nextInt();
        int final_col = scan.nextInt();
        Point final_point = new Point(final_row,final_col);
        int n = scan.nextInt();
        Map<Integer,Set<Integer>> valid = new HashMap<>();
        while (n-- > 0){
        int row = scan.nextInt();
        int col_1 = scan.nextInt();
        int col_2 = scan.nextInt();
            if(!valid.containsKey(row)){
                valid.put(row,new HashSet<>());
            }
        for(int i=col_1;i<=col_2;i++){
            valid.get(row).add(i);
        }
        }
        int res = BFS(inital_point,final_point,valid);
        System.out.println(res);

    }
    public static void main(String[] args){
        KingPath();
    }
}