package main

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

const OFFSET = 200005
const MAX_V = 400020

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

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(reader, &n); err != nil {
		return
	}

	type Point struct {
		u, v int
	}

	var S0, S1 []Point

	for i := 0; i < n; i++ {
		var x, y int
		fmt.Fscan(reader, &x, &y)
		u := x + y
		v := x - y
		p := (u%2 + 2) % 2
		if p == 0 {
			S0 = append(S0, Point{u, v})
		} else {
			S1 = append(S1, Point{u, v})
		}
	}

	ans := int64(0)

	for p := 0; p <= 1; p++ {
		var S []Point
		if p == 0 {
			S = S1 
		} else {
			S = S0 
		}

		if len(S) == 0 {
			continue
		}

		min_v_in_S := int(1e9)
		max_v_in_S := int(-1e9)

		max_u := make([]int, MAX_V)
		min_u := make([]int, MAX_V)
		for i := 0; i < MAX_V; i++ {
			max_u[i] = -1e9
			min_u[i] = 1e9
		}

		for _, pt := range S {
			v_idx := pt.v + OFFSET
			if pt.v < min_v_in_S {
				min_v_in_S = pt.v
			}
			if pt.v > max_v_in_S {
				max_v_in_S = pt.v
			}
			if pt.u > max_u[v_idx] {
				max_u[v_idx] = pt.u
			}
			if pt.u < min_u[v_idx] {
				min_u[v_idx] = pt.u
			}
		}

		max_u_below := make([]int, MAX_V)
		min_u_below := make([]int, MAX_V)
		max_u_above := make([]int, MAX_V)
		min_u_above := make([]int, MAX_V)

		max_u_below[0] = max_u[0]
		min_u_below[0] = min_u[0]
		for i := 1; i < MAX_V; i++ {
			max_u_below[i] = max(max_u_below[i-1], max_u[i])
			min_u_below[i] = min(min_u_below[i-1], min_u[i])
		}

		max_u_above[MAX_V-1] = max_u[MAX_V-1]
		min_u_above[MAX_V-1] = min_u[MAX_V-1]
		for i := MAX_V - 2; i >= 0; i-- {
			max_u_above[i] = max(max_u_above[i+1], max_u[i])
			min_u_above[i] = min(min_u_above[i+1], min_u[i])
		}

		for v := min_v_in_S + 1; v < max_v_in_S; v++ {
			if (v%2+2)%2 != p {
				continue
			}

			v_idx := v + OFFSET

			R1 := max_u_above[v_idx+1]
			R2 := max_u_below[v_idx-1]
			L1 := min_u_above[v_idx+1]
			L2 := min_u_below[v_idx-1]

			R := min(R1, R2)
			L := max(L1, L2)

			if R > L {
				ans += int64((R - L) / 2)
			}
		}
	}

	fmt.Println(ans)
}