#include <bits/stdc++.h>
using namespace std;

const int ROW = 10, COL = 9;
int dist[10][9];

// Kiểm tra xem tọa độ có nằm trong bàn cờ không
bool inBoard(int y, int x) {
    return y >= 0 && y < ROW && x >= 0 && x < COL;
}

// Kiểm tra xem từ vị trí hiện tại (y, x) có thể ăn được quân địch (y2, x2) không
// Sử dụng quân cờ tại (y3, x3) làm vật cản
bool canAttack(int y, int x, int y2, int x2, int y3, int x3) {
    // Kiểm tra hàng ngang
    if (y == y2 && y == y3) {
        int min_x = min(x, x2);
        int max_x = max(x, x2);
        // Quân cờ (y3, x3) phải nằm giữa (y, x) và (y2, x2)
        if (x3 > min_x && x3 < max_x) return true;
    }
    // Kiểm tra hàng dọc
    if (x == x2 && x == x3) {
        int min_y = min(y, y2);
        int max_y = max(y, y2);
        // Quân cờ (y3, x3) phải nằm giữa (y, x) và (y2, x2)
        if (y3 > min_y && y3 < max_y) return true;
    }
    return false;
}

int bfs(int y1, int x1, int y2, int x2, int y3, int x3) {
    // Khởi tạo khoảng cách là -1 (chưa thăm)
    memset(dist, -1, sizeof(dist));
    queue<pair<int, int>> q;

    q.push({y1, x1});
    dist[y1][x1] = 0;

    // Mảng hướng di chuyển: Trái, Phải, Lên, Xuống
    int dy[] = {0, 0, -1, 1};
    int dx[] = {-1, 1, 0, 0};

    while (!q.empty()) {
        pair<int, int> u = q.front();
        q.pop();
        int y = u.first;
        int x = u.second;

        // Kiểm tra nếu từ ô hiện tại có thể ăn được quân địch
        if (canAttack(y, x, y2, x2, y3, x3)) {
            return dist[y][x] + 1; // Trả về số bước đi + 1 nước ăn
        }

        // Duyệt các hướng di chuyển
        for (int i = 0; i < 4; i++) {
            int ny = y + dy[i];
            int nx = x + dx[i];

            // Nếu ô tiếp theo hợp lệ và chưa được thăm
            if (inBoard(ny, nx) && dist[ny][nx] == -1) {
                dist[ny][nx] = dist[y][x] + 1;
                q.push({ny, nx});
            }
        }
    }
    return -1; // Không tìm được đường đi
}

int main() {
    int y1, x1, y2, x2, y3, x3;
    cin >> y1 >> x1 >> y2 >> x2 >> y3 >> x3;
    cout << bfs(y1, x1, y2, x2, y3, x3) << endl;
    return 0;
}

#include <iostream>
#include <cmath>
#include <cstdlib>
using namespace std;

int main() {
    int y1, x1, y2, x2, y3, x3;
    cin >> y1 >> x1 >> y2 >> x2 >> y3 >> x3;

    // Kiểm tra nếu Pháo đang ở vị trí có thể ăn ngay
    // (Cần kiểm tra điều kiện nhảy qua y3)
    bool can_start_eat = false;
    if (y1 == y2 && y1 == y3 && x3 > min(x1, x2) && x3 < max(x1, x2)) can_start_eat = true;
    if (x1 == x2 && x1 == x3 && y3 > min(y1, y2) && y3 < max(y1, y2)) can_start_eat = true;
    if (can_start_eat) {
        cout << 1 << endl;
        return 0;
    }

    int min_steps = 1e9;

    // Xét các trường hợp Pháo có thể đến ăn
    // Trường hợp 1: Ăn theo hàng ngang
    if (y2 == y3) {
        // Pháo cần đến một cột x' sao cho (y2, x') -> (y2, x2) có (y3, x3) ở giữa
        // Điều đó có nghĩa là x' và x2 nằm ở 2 phía khác nhau của x3.
        // Hoặc x' và x2 nằm cùng phía nhưng x3 không ở giữa.
        // Thực tế, để (y3, x3) nằm giữa, ta cần:
        // Pháo tại (y', x') -> Ăn (y2, x2) qua (y3, x3)
        // Điều kiện: y' = y2 = y3? Không, Pháo phải nằm trên hàng ngang đó.
        // Vậy Pháo nằm ở hàng y2.
        // Cần tìm x' thỏa: x' và x2 nằm 2 bên x3.
        // Tức là (x' < x3 < x2) hoặc (x2 < x3 < x').
        // Nếu x' == x2 thì không ăn được (không có vật cản).
        // Vậy có 2 vị trí 'công kích' cố định: 
        // 1. Xét bên trái x3: nếu x3 > x2, vị trí là (y2, x3 + 1) hoặc đi về phía đó.
        //    Thực ra vị trí chính xác là (y2, x') sao cho x' và x2 ở 2 bên x3.
        //    Nếu x2 < x3, thì x' phải > x3.
        //    Nếu x2 > x3, thì x' phải < x3.
        //    Chỉ có 2 hướng.

        // Xác định các vị trí đích (target positions) có thể ăn được:
        int target_x_1 = -1, target_x_2 = -1;
        if (x2 < x3) target_x_1 = x3 + 1; // Pháo ở bên phải x3
        if (x2 > x3) target_x_1 = x3 - 1; // Pháo ở bên trái x3

        // Nếu x2 == x3, không thể ăn (quân địch và quân nhảy trùng nhau, hoặc không có vật cản đúng nghĩa)
        // Giả sử input hợp lệ, x2 != x3.

        // Tính khoảng cách Manhattan từ (y1, x1) đến các vị trí đích này
        if (target_x_1 != -1 && target_x_1 >= 0 && target_x_1 < 9) {
            // Nếu Pháo đang ở hàng y2 và cột nằm giữa x3 và target_x_1?
            // Không, Pháo có thể di chuyển tự do.
            // Đường đi ngắn nhất đến (y2, target_x_1) là |y1 - y2| + |x1 - target_x_1|
            int dist = abs(y1 - y2) + abs(x1 - target_x_1);
            // +1 nước ăn
            min_steps = min(min_steps, dist + 1);
        }
    }

    // Trường hợp 2: Ăn theo hàng dọc
    if (x2 == x3) {
        int target_y_1 = -1;
        if (y2 < y3) target_y_1 = y3 + 1;
        if (y2 > y3) target_y_1 = y3 - 1;

        if (target_y_1 != -1 && target_y_1 >= 0 && target_y_1 < 10) {
            int dist = abs(x1 - x2) + abs(y1 - target_y_1);
            min_steps = min(min_steps, dist + 1);
        }
    }

    if (min_steps > 1000) cout << -1 << endl;
    else cout << min_steps << endl;

    return 0;
}