package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type Interval struct {
	L, R int64
}

func abs(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func min(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var N, M, x, y int64
	_, err := fmt.Fscan(reader, &N, &x, &M, &y)
	if err != nil {
		return
	}

	D := abs(x - y)

	var intervals []Interval
	var isolatedU int64 = 0

	var I1, I2 int64 = 0, 0

	for u := int64(1); u <= N; u++ {
		L := max(1, abs(u-D))
		R := min(M, u+D)

		if L > R {
			isolatedU++
			continue
		}

		intervals = append(intervals, Interval{L, R})

		cL := max(1, abs(u-D)+1)
		cR := min(M, u+D-1)

		var crossCount int64 = 0
		if cL <= cR {
			crossCount = cR - cL + 1
		}

		totalCount := R - L + 1
		touchCount := totalCount - crossCount

		I2 += crossCount
		I1 += touchCount
	}

	sort.Slice(intervals, func(i, j int) bool {
		if intervals[i].L == intervals[j].L {
			return intervals[i].R < intervals[j].R
		}
		return intervals[i].L < intervals[j].L
	})

	var mergedCount int64 = 0
	var coveredW int64 = 0
	var currentL int64 = -1
	var currentR int64 = -1

	for _, iv := range intervals {
		if currentR < iv.L {
			if currentL != -1 {
				mergedCount++
				coveredW += currentR - currentL + 1
			}
			currentL = iv.L
			currentR = iv.R
		} else {
			currentR = max(currentR, iv.R)
		}
	}

	if currentL != -1 {
		mergedCount++
		coveredW += currentR - currentL + 1
	}

	isolatedW := M - coveredW
	K_draw := mergedCount + isolatedU + isolatedW
	V_draw := I1 + 2*I2

	F := int64(1) + K_draw + V_draw

	fmt.Println(F)
}