Consider the following game for two players. There is one white token and some number of black tokens. Each token is placed on a plane in a point with integer coordinates *x* and *y*.

The players take turn making moves, white starts. On each turn, a player moves all tokens of their color by 1 to up, down, left or right. Black player can choose directions for each token independently.

After a turn of the white player the white token can not be in a point where a black token is located. There are no other constraints on locations of the tokens: positions of black tokens can coincide, after a turn of the black player and initially the white token can be in the same point with some black point. If at some moment the white player can't make a move, he loses. If the white player makes 10<sup class="upper-index">100500</sup> moves, he wins.

You are to solve the following problem. You are given initial positions of all black tokens. It is guaranteed that initially all these positions are distinct. In how many places can the white token be located initially so that if both players play optimally, the black player wins?
The first line contains a single integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) — the number of black points.

The (*i* + 1)-th line contains two integers *x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub> ( - 10<sup class="upper-index">5</sup> ≤ *x*<sub class="lower-index">*i*</sub>, *y*<sub class="lower-index">*i*</sub>,  ≤ 10<sup class="upper-index">5</sup>) — the coordinates of the point where the *i*-th black token is initially located.

It is guaranteed that initial positions of black tokens are distinct.
In the first and second examples initial positions of black tokens are shown with black points, possible positions of the white token (such that the black player wins) are shown with white points.

The first example: <img class="tex-graphics" src="https://espresso.codeforces.com/5054b8d2df2fac92c92f96fae82d21c365d12983.png" style="max-width: 100.0%;max-height: 100.0%;"/>

The second example: <img class="tex-graphics" src="https://espresso.codeforces.com/eb795dd6abb95cfafb1d1cb7d8c8798825dcc180.png" style="max-width: 100.0%;max-height: 100.0%;"/>

In the third example the white tokens should be located in the inner square 2 × 2, to make the black player win. <img class="tex-graphics" src="https://espresso.codeforces.com/6dfd863f649b92860dfd6b446ea004abc01b71a6.png" style="max-width: 100.0%;max-height: 100.0%;"/>
4
-2 -1
0 1
0 -3
2 -1
4
4
-2 0
-1 1
0 -2
1 -1
2
16
2 1
1 2
-1 1
0 1
0 0
1 1
2 -1
2 0
1 0
-1 -1
1 -1
2 2
0 -1
-1 0
0 2
-1 2
4
1
1 2
0
4
0 99999
-99999 0
99999 0
0 -99999
9999800001
10
-1 3
-1 7
-8 -4
5 14
-6 -7
11 -8
-11 0
5 -1
9 4
-2 -14
110
50
-15 -80
-80 21
90 38
-100 27
-64 -75
-10 59
38 44
-31 -91
97 76
87 43
5 43
-73 74
-45 42
31 -100
-87 19
-21 -13
-71 38
-54 -39
-89 -32
-18 99
-44 -78
9 76
-69 -40
-29 23
-88 42
-95 86
45 15
-39 100
17 -33
5 -48
-4 -22
-19 54
-13 -64
-86 68
-52 -95
-73 -29
-24 -93
-60 96
41 57
55 43
-64 15
-43 9
29 88
44 -2
67 -94
-20 -81
-75 -74
-80 -44
-49 -7
39 -59
17145
2
-3 0
3 2
0
3
-5 3
4 -5
-3 2
0
4
-5 1
0 -3
-1 4
5 -5
0
4
-1 4
-3 2
-2 1
-5 3
0
5
-3 -5
5 2
-4 1
-2 0
1 2
0
5
2 3
1 -1
0 2
0 5
3 2
0
6
-1 2
5 -4
0 4
3 0
-4 -1
-3 -2
3
6
-3 4
-1 -3
1 -4
1 -1
-5 -1
1 4
0
7
0 4
0 3
-1 3
4 3
1 3
-4 4
5 4
0
7
4 4
2 3
5 -2
-1 1
2 2
-2 -2
-1 2
0
8
2 -4
-4 -2
-3 3
-3 -1
4 -4
2 3
4 -5
0 0
4
8
4 -4
5 -5
3 2
-2 5
-4 -2
2 5
-5 5
5 4
2
9
4 -5
-4 -3
4 -4
1 0
5 -1
-3 1
5 -4
2 -4
4 -3
4
9
-2 0
-4 -4
0 4
2 2
-3 -2
1 3
-5 5
-3 -3
-1 1
5
10
-1 -2
-5 2
-5 0
-1 0
4 0
4 5
0 -3
-3 -3
-5 5
3 -4
2
10
2 -3
-3 3
-1 -1
3 -5
5 -3
0 5
-4 -4
2 -4
-2 -5
-2 4
11
10
2 -4
0 -3
3 2
-1 3
1 -1
4 -5
-4 2
1 0
-2 -5
-2 2
3
10
-4 -2
-1 0
1 -3
2 5
3 1
3 -3
2 4
-2 -1
-3 3
5 2
7
10
2 0
1 2
4 0
3 -1
4 3
-5 4
-4 -1
1 -1
2 -1
-5 -4
3
10
3 4
-2 -3
-2 5
-2 1
5 4
2 -1
5 -4
0 1
4 4
3 -1
6
10
-1 3
2 3
3 2
-4 -3
-2 -5
5 -5
-4 -4
0 1
4 -1
3 3
11
10
1 -3
0 4
-1 3
-2 3
4 1
-1 5
5 4
-5 5
-4 -2
-5 1
5
10
5 -1
-2 5
-5 -1
-3 -3
-5 -4
-3 -2
-1 -4
2 5
4 -5
1 -4
5
10
-1 0
5 -1
-4 1
-3 0
-5 -1
-3 -4
3 3
-2 2
-3 -2
3 -1
2
20
-16 24
9 13
-1 -3
5 7
-20 17
21 5
-10 8
0 -14
17 -5
7 1
-6 16
-18 -9
-7 -8
-13 -23
4 4
10 -3
2 -5
-18 24
19 -19
12 -25
268
20
-4 23
-10 3
20 25
24 -23
1 18
-23 -24
-20 -6
7 22
11 -18
-25 -19
7 -6
-9 22
-24 -2
-9 -17
-1 12
-20 -21
-19 -24
10 -20
20 8
25 -14
312
20
21 20
23 -21
-22 24
-18 -2
-6 -15
-20 -10
-15 21
-18 5
13 10
-11 15
-6 -1
17 6
-13 -23
8 -9
-24 21
8 11
21 9
22 12
-2 -21
-12 -10
459
20
-5 -7
-17 22
13 -4
19 8
2 6
-4 1
7 -15
-5 -15
-14 -13
14 8
-13 -23
8 4
-13 18
-17 3
9 3
7 -11
6 -16
-15 9
-24 -17
-20 -18
227
20
-9 5
-25 -4
14 -22
-17 23
-20 -8
19 22
23 -3
-23 -11
-2 -15
22 -4
-10 -16
16 22
9 9
-18 16
-25 6
8 -10
-2 -17
-12 6
20 -10
17 -6
529
20
-13 15
1 14
-12 7
-18 -15
-19 -11
-7 6
7 -15
4 18
-4 10
-23 16
-8 -15
-3 14
-8 1
17 19
15 19
-3 -12
-25 16
-7 -1
-14 1
18 3
295
20
-17 7
0 -21
15 -10
-5 12
18 -12
-19 11
24 -19
-25 -1
-5 -25
20 -23
-4 9
7 -15
8 -9
23 -15
-2 5
10 -4
12 -24
25 2
5 -6
2 25
577
20
17 23
-7 8
3 9
9 -22
-9 -14
-18 -10
-4 2
10 -3
-9 19
-7 9
-22 4
6 14
-9 -18
2 0
-17 4
6 20
24 13
22 4
-14 -1
-6 -14
454
20
-10 16
24 18
-1 -22
1 4
4 -19
-22 8
-20 -20
25 24
-4 8
7 -11
-17 -14
25 -12
24 23
-18 15
23 -1
-11 -14
-4 -6
-14 18
-10 18
2 -17
487
20
11 1
-15 23
5 24
7 -13
-13 -13
-25 20
22 -16
-23 -2
11 -21
12 1
2 3
-3 -17
4 21
-17 12
13 -14
1 4
23 -22
-18 9
14 5
-23 -3
502
#FB HACKERCUP
import os,sys,math
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from _builtin_ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

from bisect import bisect_left as lower_bound, bisect_right as upper_bound 
def so():  return int(input())
def st():  return input()
def mj():  return map(int,input().strip().split(" "))
def msj(): return map(str,input().strip().split(" "))
def le():  return list(map(int,input().split()))
def lebe():return list(map(int, input()))

# def dmain():
#     sys.setrecursionlimit(1000000)
#     threading.stack_size(1024000)
#     thread = threading.Thread(target=main)
#     thread.start()
def joro(L):
    return(''.join(map(str, L)))
def cheems(c,d):
    a=1
    while(d!=0):
        if(d%2==1):
            a*=c
        c=c*c
        d=d//2
    return a

        

def decimalToBinary(n): return bin(n).replace("0b","")


def isprime(n):
    for i in range(2,int(n**0.5)+1):
        if n%i==0:
            return False
    return True
# def npr(n, r):
#     return factorial(n) // factorial(n - r) if n >= r else 0
 
 
# def ncr(n, r):
#     return factorial(n) // (factorial(r) * factorial(n - r)) if n >= r else 0
 
 
def lower_bound(li, num):
    answer = -1
    start = 0
    end = len(li) - 1
 
    while (start <= end):
        middle = (end + start) // 2
        if li[middle] >= num:
            answer = middle
            end = middle - 1
        else:
            start = middle + 1
    return answer  # min index where x is not less than num
 
 
def upper_bound(li, num):
    answer = -1
    start = 0
    end = len(li) - 1
 
    while (start <= end):
        middle = (end + start) // 2
 
        if li[middle] <= num:
            answer = middle
            start = middle + 1
 
        else:
            end = middle - 1
    return answer  # max index where x is not greater than num
def tir(a,b,c):
    if(0==c):
        return 1
    if(len(a)<=b):
        return 0
    
    if(c!=-1):
        return (tir(a,1+b,c+a[b]) or tir(a,b+1,c-a[b]) or tir(a,1+b,c)) 
        
        
    else:
        return (tir(a,1+b,a[b]) or tir(a,b+1,-a[b]) or tir(a,1+b,-1))
        
 
def abs(x):
    return x if x >= 0 else -x
doi=int(1e9+7)
boi=int(1e9-7)
koi=int(5+2e6)
moi=int(4e6+5+100)
def binary_search(li, val, lb, ub):
    # print(lb, ub, li)
    ans = -1
    while (lb <= ub):
        mid = (lb + ub) // 2
        # print('mid is',mid, li[mid])
        if li[mid] > val:
            ub = mid - 1
        elif val > li[mid]:
            lb = mid + 1
        else:
            ans = mid  # return index
            break
    return ans
 
 
def kadane(x):  # maximum sum contiguous subarray
    sum_so_far = 0
    current_sum = 0
    for i in x:
        current_sum += i
        if current_sum < 0:
            current_sum = 0
        else:
            sum_so_far = max(sum_so_far, current_sum)
    return sum_so_far
def wubu(m):
    import math as my
    d=0
    while(not m%2):
        m=m//2
        d=1+d
    for i in range(3,int(my.sqrt(m))+1,2):
        while(not m%i):
            m=m//i
            d=1+d
    return int(m>1)+d
 
def pref(li):
    pref_sum = [0]
    for i in li:
        pref_sum.append(pref_sum[-1] + i)
    return pref_sum
 
 
def SieveOfEratosthenes(n):
    prime = [True for i in range(n + 1)]
    p = 2
    li = []
    while (p * p <= n):
        if (prime[p] == True):
            for i in range(p * p, n + 1, p):
                prime[i] = False
        p += 1
 
    for p in range(2, len(prime)):
        if prime[p]:
            li.append(p)
    return li
 
 
def primefactors(n):
    import math as my
    factors = []
    while (n % 2 == 0):
        factors.append(2)
        n //= 2
    for i in range(3, int(my.sqrt(n)) + 1, 2):  # only odd factors left
        while n % i == 0:
            factors.append(i)
            n //= i
    if n > 2:  # incase of prime
        factors.append(n)
    return factors
         
    
def read():
    sys.stdin  = open('input.txt', 'r')  
    sys.stdout = open('output.txt', 'w') 
def tr(n):
    return n*(n+1)//2

def bro(q,r,c):
    bec,pot,h=0,0,0
    ds=[]
    bs=[]
    es=[]
    for i in range(c):
        while(h<len(r) and r[h]<=q[i][0]):
            pot=0
            ds.clear()
            bs.clear()
            h=1+h
    for i in range(c):
        ds.append(q[i][1])
        es.append(q[i][1])
    ds=list(set(ds))
    
    for i in ds:
        bs.append(es.count(i))
    
    print(bs)
    for i in range(c):
        if(q[i][0]>r[h-1]):
            bec=bec+pot-bs[i]
            pot=1+pot
            
            
    return bec
        
            
            
            
        
    
def iu():
    import sys
    input = sys.stdin.readline
    import math as my
    import bisect as by
    m=so()
    bec=0
    A=[0]*moi
    B=[0]*moi
    C=[0]*moi
    D=[0]*moi
    E=[0]*moi
    F=[0]*moi
    for i in range(koi*2+1):
        A[i]=sys.maxsize
        B[i]=-sys.maxsize
    for i in range(1,m+1):
        p,q=mj()
        r=p+q+koi
        s=p-q
        A[r]=min(A[r],s)
        B[r]=max(B[r],s)
    for i in range(2):
        C[i]=A[i]
        D[i]=B[i]
    for i in range(2,1+2*koi):
        C[i]=min(C[i-2],A[i])
        D[i]=max(B[i],D[i-2])
    for i in range(2*koi-2,2*koi+1):
        E[i]=A[i]
        F[i]=B[i]
    for i in range(2*koi-2,-1,-1):
        E[i]=min(E[2+i],A[i])
        F[i]=max(B[i],F[2+i])
    for i in range(1,2*koi+1,1):
        se=min(D[i-1],F[1+i])-max(C[i-1],E[1+i])
        bec=max(0,se//2)+bec
    print(bec)
    
    
    
    
    
    
    
   

def main():
    for i in range(1):
        iu()
        
        
# region fastio
# template taken from https://github.com/cheran-senthil/PyRival/blob/master/templates/template.py

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

# endregion

            




if __name__ == "__main__":
    #read()
    main()
    #dmain()

# Comment Read()