For problem statement at 0-999/400-499/400-409/406/problemE.txt this is a correct solution, but verifier at 0-999/400-499/400-409/406/verifierE.go ends with reference runtime error on test 1: exec: "ref406E.bin": executable file not found in $PATH
Input used:
1 3
0 1
1 1
0 1


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

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, m int
	fmt.Fscan(reader, &n, &m)

	Z := make([]int, 0, m)
	O := make([]int, 0, m)

	for i := 0; i < m; i++ {
		var s, f int
		fmt.Fscan(reader, &s, &f)
		if s == 0 {
			Z = append(Z, f)
		} else {
			O = append(O, f)
		}
	}

	sort.Ints(Z)
	sort.Ints(O)

	Nz := len(Z)
	No := len(O)

	INF := int64(2e18)
	E_min := INF

	if Nz >= 3 {
		E0 := int64(n) - int64(Z[Nz-1]-Z[0])
		if E0 < E_min {
			E_min = E0
		}
	}

	if No >= 3 {
		E3 := int64(n) - int64(O[No-1]-O[0])
		if E3 < E_min {
			E_min = E3
		}
	}

	if Nz >= 2 && No >= 1 {
		for i := 0; i < No; i++ {
			o := O[i]
			var val int64 = 0
			if o < Z[0] {
				val = int64(Z[0] - o)
			} else if o > Z[Nz-1] {
				val = int64(o - Z[Nz-1])
			}
			if val < E_min {
				E_min = val
			}
		}
	}

	if Nz >= 1 && No >= 2 {
		for i := 0; i < Nz; i++ {
			z := Z[i]
			var val int64 = 0
			if z < O[0] {
				val = int64(O[0] - z)
			} else if z > O[No-1] {
				val = int64(z - O[No-1])
			}
			if val < E_min {
				E_min = val
			}
		}
	}

	var total_count int64 = 0

	if Nz >= 3 {
		E0 := int64(n) - int64(Z[Nz-1]-Z[0])
		if E0 == E_min {
			V_min := Z[0]
			V_max := Z[Nz-1]
			if V_min < V_max {
				C_min := int64(sort.Search(Nz, func(i int) bool { return Z[i] > V_min }))
				idx_max := sort.Search(Nz, func(i int) bool { return Z[i] >= V_max })
				C_max := int64(Nz - idx_max)
				C_mid := int64(Nz) - C_min - C_max

				cnt := C_max*(C_min*(C_min-1)/2) + C_min*(C_max*(C_max-1)/2) + C_min*C_max*C_mid
				total_count += cnt
			} else {
				nz := int64(Nz)
				total_count += nz * (nz - 1) * (nz - 2) / 6
			}
		}
	}

	if No >= 3 {
		E3 := int64(n) - int64(O[No-1]-O[0])
		if E3 == E_min {
			V_min := O[0]
			V_max := O[No-1]
			if V_min < V_max {
				C_min := int64(sort.Search(No, func(i int) bool { return O[i] > V_min }))
				idx_max := sort.Search(No, func(i int) bool { return O[i] >= V_max })
				C_max := int64(No - idx_max)
				C_mid := int64(No) - C_min - C_max

				cnt := C_max*(C_min*(C_min-1)/2) + C_min*(C_max*(C_max-1)/2) + C_min*C_max*C_mid
				total_count += cnt
			} else {
				no := int64(No)
				total_count += no * (no - 1) * (no - 2) / 6
			}
		}
	}

	if Nz >= 2 && No >= 1 {
		C_min := int64(sort.Search(Nz, func(i int) bool { return Z[i] > Z[0] }))
		idx_max := sort.Search(Nz, func(i int) bool { return Z[i] >= Z[Nz-1] })
		C_max := int64(Nz - idx_max)

		for i := 0; i < No; {
			o := O[i]
			j := i
			for j < No && O[j] == o {
				j++
			}
			cnt_o := int64(j - i)

			var val int64 = 0
			if o < Z[0] {
				val = int64(Z[0] - o)
			} else if o > Z[Nz-1] {
				val = int64(o - Z[Nz-1])
			}

			if val == E_min {
				var pairs_in_Z int64 = 0
				if val == 0 {
					idx_ge := sort.Search(Nz, func(k int) bool { return Z[k] >= o })
					C_less := int64(idx_ge)
					idx_gt := sort.Search(Nz, func(k int) bool { return Z[k] > o })
					C_equal := int64(idx_gt - idx_ge)
					C_greater := int64(Nz - idx_gt)

					pairs_in_Z = C_less*C_greater + C_less*C_equal + C_equal*C_greater + C_equal*(C_equal-1)/2
				} else if o < Z[0] {
					pairs_in_Z = C_min*(int64(Nz)-C_min) + C_min*(C_min-1)/2
				} else if o > Z[Nz-1] {
					pairs_in_Z = C_max*(int64(Nz)-C_max) + C_max*(C_max-1)/2
				}
				total_count += pairs_in_Z * cnt_o
			}

			i = j
		}
	}

	if Nz >= 1 && No >= 2 {
		C_min := int64(sort.Search(No, func(i int) bool { return O[i] > O[0] }))
		idx_max := sort.Search(No, func(i int) bool { return O[i] >= O[No-1] })
		C_max := int64(No - idx_max)

		for i := 0; i < Nz; {
			z := Z[i]
			j := i
			for j < Nz && Z[j] == z {
				j++
			}
			cnt_z := int64(j - i)

			var val int64 = 0
			if z < O[0] {
				val = int64(O[0] - z)
			} else if z > O[No-1] {
				val = int64(z - O[No-1])
			}

			if val == E_min {
				var pairs_in_O int64 = 0
				if val == 0 {
					idx_ge := sort.Search(No, func(k int) bool { return O[k] >= z })
					C_less := int64(idx_ge)
					idx_gt := sort.Search(No, func(k int) bool { return O[k] > z })
					C_equal := int64(idx_gt - idx_ge)
					C_greater := int64(No - idx_gt)

					pairs_in_O = C_less*C_greater + C_less*C_equal + C_equal*C_greater + C_equal*(C_equal-1)/2
				} else if z < O[0] {
					pairs_in_O = C_min*(int64(No)-C_min) + C_min*(C_min-1)/2
				} else if z > O[No-1] {
					pairs_in_O = C_max*(int64(No)-C_max) + C_max*(C_max-1)/2
				}
				total_count += pairs_in_O * cnt_z
			}

			i = j
		}
	}

	fmt.Println(total_count)
}
```