For problem statement at 1000-1999/1200-1299/1210-1219/1218/problemC.txt this is a correct solution, but verifier at 1000-1999/1200-1299/1210-1219/1218/verifierC.go ends with all tests passed can you fix the verifier? ```go
package main

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

func nextInt(in *bufio.Reader) int {
	var n int
	var b byte
	var err error
	for {
		b, err = in.ReadByte()
		if err != nil || b > ' ' {
			break
		}
	}
	if err != nil {
		return 0
	}
	for b > ' ' {
		n = n*10 + int(b-'0')
		b, err = in.ReadByte()
		if err != nil {
			break
		}
	}
	return n
}

func nextInt64(in *bufio.Reader) int64 {
	var n int64
	var b byte
	var err error
	for {
		b, err = in.ReadByte()
		if err != nil || b > ' ' {
			break
		}
	}
	if err != nil {
		return 0
	}
	for b > ' ' {
		n = n*10 + int64(b-'0')
		b, err = in.ReadByte()
		if err != nil {
			break
		}
	}
	return n
}

type Pair struct {
	start int
	e     int64
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	var N, M, K int
	N = nextInt(in)
	M = nextInt(in)
	K = nextInt(in)

	Cost := make([][]int64, N)
	H_pairs := make([][][]Pair, N)
	V_pairs := make([][][]Pair, N)

	for i := 0; i < N; i++ {
		Cost[i] = make([]int64, M)
		H_pairs[i] = make([][]Pair, M)
		V_pairs[i] = make([][]Pair, M)
	}

	for i := 0; i < K; i++ {
		x := nextInt(in)
		y := nextInt(in)
		d := nextInt(in)
		t := nextInt(in)
		e := nextInt64(in)

		type Pt struct{ r, c int }
		var pts []Pt

		if x+y >= t && (x+y-t)%4 == 0 {
			pts = append(pts, Pt{x, y})
		}
		if x+y >= t+1 && (x+y-(t+1))%4 == 0 {
			pts = append(pts, Pt{x + d, y - d})
		}
		if x+y+d >= t+2 && (x+y+d-(t+2))%4 == 0 {
			pts = append(pts, Pt{x + d, y})
		}
		if x+y+d >= t+3 && (x+y+d-(t+3))%4 == 0 {
			pts = append(pts, Pt{x, y + d})
		}

		for _, pt := range pts {
			Cost[pt.r][pt.c] += e
		}

		if len(pts) == 2 {
			pt1 := pts[0]
			pt2 := pts[1]
			if pt1.r == pt2.r {
				if pt1.c > pt2.c {
					pt1, pt2 = pt2, pt1
				}
				H_pairs[pt1.r][pt2.c] = append(H_pairs[pt1.r][pt2.c], Pair{start: pt1.c, e: e})
			} else if pt1.c == pt2.c {
				if pt1.r > pt2.r {
					pt1, pt2 = pt2, pt1
				}
				V_pairs[pt2.r][pt1.c] = append(V_pairs[pt2.r][pt1.c], Pair{start: pt1.r, e: e})
			}
		}
	}

	DPV := make([][]int64, N)
	DPH := make([][]int64, N)
	const INF int64 = 1e18

	for i := 0; i < N; i++ {
		DPV[i] = make([]int64, M)
		DPH[i] = make([]int64, M)
		for j := 0; j < M; j++ {
			DPV[i][j] = INF
			DPH[i][j] = INF
		}
	}

	DPV[0][0] = Cost[0][0]
	DPH[0][0] = Cost[0][0]

	for i := 0; i < N; i++ {
		for c := 0; c < M; c++ {
			if DPV[i][c] == INF {
				continue
			}
			var costSum int64 = 0
			for j := c + 1; j < M; j++ {
				costSum += Cost[i][j]
				for _, p := range H_pairs[i][j] {
					if p.start >= c {
						costSum -= p.e
					}
				}
				if DPV[i][c]+costSum < DPH[i][j] {
					DPH[i][j] = DPV[i][c] + costSum
				}
			}
		}

		for j := 0; j < M; j++ {
			if DPH[i][j] == INF {
				continue
			}
			var costSum int64 = 0
			for k := i + 1; k < N; k++ {
				costSum += Cost[k][j]
				for _, p := range V_pairs[k][j] {
					if p.start >= i {
						costSum -= p.e
					}
				}
				if DPH[i][j]+costSum < DPV[k][j] {
					DPV[k][j] = DPH[i][j] + costSum
				}
			}
		}
	}

	ans := DPH[N-1][M-1]
	if DPV[N-1][M-1] < ans {
		ans = DPV[N-1][M-1]
	}

	fmt.Println(ans)
}
```