For problem statement at 0-999/900-999/930-939/930/problemD.txt this is a correct solution, but verifier at 0-999/900-999/930-939/930/verifierD.go ends with test 1 failed: expected 56 got 0

exit status 1 can you fix the verifier? ```go
package main

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

const OFFSET = 250000
const MAX_V = 500000
const INF = 1000000000

func floorDiv2(n int) int {
	if n >= 0 {
		return n / 2
	}
	return (n - 1) / 2
}

func ceilDiv2(n int) int {
	if n >= 0 {
		return (n + 1) / 2
	}
	return n / 2
}

func count_parity(L, R, p int) int64 {
	if L > R {
		return 0
	}
	rem := p % 2
	if rem < 0 {
		rem += 2
	}

	min_k := ceilDiv2(L - rem)
	max_k := floorDiv2(R - rem)

	if min_k > max_k {
		return 0
	}
	return int64(max_k - min_k + 1)
}

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

	max_u := make([]int, MAX_V)
	min_u := make([]int, MAX_V)

	for i := 0; i < MAX_V; i++ {
		max_u[i] = -INF
		min_u[i] = INF
	}

	for i := 0; i < n; i++ {
		var x, y int
		fmt.Fscan(reader, &x, &y)
		u := x + y
		v := x - y
		idx := v + OFFSET
		if u > max_u[idx] {
			max_u[idx] = u
		}
		if u < min_u[idx] {
			min_u[idx] = u
		}
	}

	min_v_b := MAX_V
	max_v_b := -1

	for i := 0; i < MAX_V; i++ {
		if max_u[i] != -INF {
			if i < min_v_b {
				min_v_b = i
			}
			if i > max_v_b {
				max_v_b = i
			}
		}
	}

	if min_v_b >= max_v_b {
		fmt.Println(0)
		return
	}

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

		pref_min_u[i] = pref_min_u[i-1]
		if min_u[i] < pref_min_u[i] {
			pref_min_u[i] = min_u[i]
		}
	}

	suff_max_u := make([]int, MAX_V)
	suff_min_u := make([]int, MAX_V)
	suff_max_u[MAX_V-1] = max_u[MAX_V-1]
	suff_min_u[MAX_V-1] = min_u[MAX_V-1]
	for i := MAX_V - 2; i >= 0; i-- {
		suff_max_u[i] = suff_max_u[i+1]
		if max_u[i] > suff_max_u[i] {
			suff_max_u[i] = max_u[i]
		}

		suff_min_u[i] = suff_min_u[i+1]
		if min_u[i] < suff_min_u[i] {
			suff_min_u[i] = min_u[i]
		}
	}

	var ans int64 = 0
	for v_idx := min_v_b + 1; v_idx <= max_v_b-1; v_idx++ {
		f1 := suff_max_u[v_idx+1]
		f2 := pref_max_u[v_idx-1]
		f3 := pref_min_u[v_idx-1]
		f4 := suff_min_u[v_idx+1]

		if f1 == -INF || f2 == -INF || f3 == INF || f4 == INF {
			continue
		}

		R := f1
		if f2 < R {
			R = f2
		}
		R--

		L := f3
		if f4 > L {
			L = f4
		}
		L++

		if L <= R {
			actual_v := v_idx - OFFSET
			ans += count_parity(L, R, actual_v)
		}
	}

	fmt.Println(ans)
}
```