D

#include <iostream>
#include <vector>
#include <queue>
#include <set>

using namespace std;

struct Point{
    const int x;
    const int y;

    bool operator < (const Point& other)const{
        if (x != other.x){
            return x < other.x;
        }
        return y < other.y;
    }

};


class Field{
public:
    explicit Field(int width, int height): distances_(height+1, vector<int>(width+1, -1)), width_(width), height_(height){}

    int calculate_sum_distance(Point& start){
        bfs(start);
        int result = 0;
        for (const auto& target : targets_){
            if (distances_[target.y][target.x] == -1){
                return -1;
            } else{
                result += distances_[target.y][target.x];
            }
        }

        return result;
    };

    void add_target(const Point& p){
        targets_.push_back(p);
    }

private:

    void bfs(Point& start){
        queue<Point> q;
        distances_[start.y][start.x] = 0;
        q.push(start);
        while (!q.empty()){
            auto v = q.front();
            q.pop();
            for (const auto& neighbour : get_neighbours(v)){
                if(distances_[neighbour.y][neighbour.x] == -1){
                    distances_[neighbour.y][neighbour.x] = distances_[v.y][v.x]+1;
                    q.push(neighbour);
                }
                else if(distances_[v.y][v.x] + 1 < distances_[neighbour.y][neighbour.x]){
                        distances_[neighbour.y][neighbour.x] = distances_[v.y][v.x] + 1;
                }
            }
        }
    }

    set<Point> get_neighbours(Point& v) const{
        set<Point> result;
        result.insert({v.x+1, v.y+2});
        result.insert({v.x+1, v.y-2});
        result.insert({v.x-1, v.y-2});
        result.insert({v.x-1, v.y+2});
        result.insert({v.x+2, v.y-1});
        result.insert({v.x+2, v.y+1});
        result.insert({v.x-2, v.y-1});
        result.insert({v.x-2, v.y+1});
        auto result_copy = result;
        for (auto n : result_copy){
            if (n.x < 1 || n.x > width_ || n.y < 1 || n.y > height_){
                result.erase(n);
            }
        }
        return result;
    }

    int height_;
    int width_;

    vector<vector<int>> distances_;
    vector<Point> targets_;
};

int main(){
    int height, width, target_x, target_y, knights_amount;

    cin >> height >> width;
    Field field(width, height);

    cin >> target_x >> target_y;
    Point start{target_x, target_y};

    cin >> knights_amount;

    for (int _ = 0; _ < knights_amount; ++_){
        int x, y;
        cin >> x >> y;
        field.add_target({x, y});
    }

    int dist = field.calculate_sum_distance(start);
    cout << dist;
}