import java.io.; import java.math.; import java.security.; import java.text.; import java.util.; import java.util.concurrent.; import java.util.regex.*;

public class Solution {

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n = scanner.nextInt();
    int k = scanner.nextInt();
    int xq = scanner.nextInt();
    int yq = scanner.nextInt();

    HashSet<Point> obstacles = new HashSet<Point>();
    for (int i = 0; i < k; i++) {
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        obstacles.add(new Point(x,y));
    }
    obstacles.add(new Point(0,0));
    obstacles.add(new Point(0,n+1));
    obstacles.add(new Point(n+1,0));
    obstacles.add(new Point(n+1,n+1));
    for (int i = 1; i <= n; i++) {
        obstacles.add(new Point(i,0));
        obstacles.add(new Point(i,n+1));
        obstacles.add(new Point(0,i));
        obstacles.add(new Point(n+1,i));
    }

    HashMap<Point,Integer> directionMin = new HashMap<>();

    for (Point obstacle : obstacles) {
        int xDifference = xq - obstacle.x;
        int yDifference = yq - obstacle.y;
        double slope = 0;
        if (xDifference == 0){
            slope = 0.0;
        }
        else{
            slope = (double)(yDifference)/xDifference;
        }

        if (slope == 1.0){
            if (xDifference >= 1){
                Point dir = new Point(-1,-1);
                if (!directionMin.containsKey(dir)){
                    directionMin.put(dir,Integer.MAX_VALUE);
                }
                int val = Math.min(Math.abs(xDifference),Math.abs(yDifference))-1;
                int previousVal = directionMin.get(dir);
                directionMin.put(dir,Math.min(previousVal,val));
            }
            else{
                Point dir = new Point(1,1);
                if (!directionMin.containsKey(dir)){
                    directionMin.put(dir,Integer.MAX_VALUE);
                }
                int val = Math.min(Math.abs(xDifference),Math.abs(yDifference))-1;
                int previousVal = directionMin.get(dir);
                directionMin.put(dir,Math.min(previousVal,val));
            }
        }
        if (slope == -1.0){
            if (xDifference >= 1){
                Point dir = new Point(-1,1);
                if (!directionMin.containsKey(dir)){
                    directionMin.put(dir,Integer.MAX_VALUE);
                }
                int val = Math.min(Math.abs(xDifference),Math.abs(yDifference))-1;
                int previousVal = directionMin.get(dir);
                directionMin.put(dir,Math.min(previousVal,val));
            }
            else{
                Point dir = new Point(1,-1);
                if (!directionMin.containsKey(dir)){
                    directionMin.put(dir,Integer.MAX_VALUE);
                }
                int val = Math.min(Math.abs(xDifference),Math.abs(yDifference))-1;
                int previousVal = directionMin.get(dir);
                directionMin.put(dir,Math.min(previousVal,val));
            }
        }
        if (slope == 0){
            if (xDifference == 0){
                if (yDifference>= 1){
                    Point dir = new Point(0,-1);
                    if (!directionMin.containsKey(dir)){
                        directionMin.put(dir,Integer.MAX_VALUE);
                    }
                    int val = Math.abs(yDifference)-1;
                    int previousVal = directionMin.get(dir);
                    directionMin.put(dir,Math.min(previousVal,val));
                }
                else{
                    Point dir = new Point(0,1);
                    if (!directionMin.containsKey(dir)){
                        directionMin.put(dir,Integer.MAX_VALUE);
                    }
                    int val = Math.abs(yDifference)-1;
                    int previousVal = directionMin.get(dir);
                    directionMin.put(dir,Math.min(previousVal,val));
                }
            }
            else{
                if (xDifference >= 1){
                    Point dir = new Point(-1,0);
                    if (!directionMin.containsKey(dir)){
                        directionMin.put(dir,Integer.MAX_VALUE);
                    }
                    int val = Math.abs(xDifference) -1;
                    int previousVal = directionMin.get(dir);
                    directionMin.put(dir,Math.min(previousVal,val));
                }
                else{
                    Point dir = new Point(1,0);
                    if (!directionMin.containsKey(dir)){
                        directionMin.put(dir,Integer.MAX_VALUE);
                    }
                    int val = Math.abs(xDifference)-1;
                    int previousVal = directionMin.get(dir);
                    directionMin.put(dir,Math.min(previousVal,val));
                }
            }
        }
    }
    int sumSpace = 0;
    for (Integer value : directionMin.values()) {
        sumSpace += value;
    }
    System.out.println(sumSpace);
}

private static class Point {
    int x;
    int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x &&
                y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
}

} Here is another implementation with an if-statement step by step approach.