For problem statement at 0-999/400-499/480-489/487/problemD.txt this is a correct solution, but verifier at 0-999/400-499/480-489/487/verifierD.go ends with case 1 failed: expected:
0 1
0 1
got:
0 1
-1 -1
input:
1 4 4
^^<<
C 1 3 <
A 1 1
C 1 2 >
A 1 4
exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"os"
	"strconv"
	"strings"
)

type Pair struct {
	r, c int
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)

	scanInt := func() int {
		scanner.Scan()
		n, _ := strconv.Atoi(scanner.Text())
		return n
	}

	scanString := func() string {
		scanner.Scan()
		return scanner.Text()
	}

	n := scanInt()
	m := scanInt()
	q := scanInt()

	grid := make([][]byte, n+1)
	for i := 1; i <= n; i++ {
		grid[i] = make([]byte, m+2)
		s := scanString()
		for j := 1; j <= m; j++ {
			grid[i][j] = s[j-1]
		}
	}

	dest := make([][]Pair, n+1)
	for i := 1; i <= n; i++ {
		dest[i] = make([]Pair, m+2)
	}

	B := 250
	numBlocks := (n + B - 1) / B
	L := make([]int, numBlocks)
	R := make([]int, numBlocks)
	for k := 0; k < numBlocks; k++ {
		L[k] = k*B + 1
		R[k] = (k + 1) * B
		if R[k] > n {
			R[k] = n
		}
	}

	block_dest := make([][]Pair, numBlocks)
	for k := 0; k < numBlocks; k++ {
		block_dest[k] = make([]Pair, m+2)
	}

	computeDest := func(i int) {
		for y := 1; y <= m; y++ {
			curY := y
			vis := 0
			for {
				if curY == 0 || curY == m+1 {
					dest[i][y] = Pair{i, curY}
					break
				}
				if vis&(1<<curY) != 0 {
					dest[i][y] = Pair{-1, -1}
					break
				}
				vis |= (1 << curY)
				if grid[i][curY] == '^' {
					dest[i][y] = Pair{i - 1, curY}
					break
				} else if grid[i][curY] == '<' {
					curY--
				} else {
					curY++
				}
			}
		}
	}

	computeBlock := func(k int) {
		for y := 1; y <= m; y++ {
			curX := R[k]
			curY := y
			for curX >= L[k] {
				d := dest[curX][curY]
				if d.r == -1 {
					curX, curY = -1, -1
					break
				}
				if d.c == 0 || d.c == m+1 {
					curX, curY = d.r, d.c
					break
				}
				curX = d.r
				curY = d.c
			}
			block_dest[k][y] = Pair{curX, curY}
		}
	}

	for i := 1; i <= n; i++ {
		computeDest(i)
	}
	for k := 0; k < numBlocks; k++ {
		computeBlock(k)
	}

	var out strings.Builder
	out.Grow(q * 15)

	for i := 0; i < q; i++ {
		typ := scanString()
		if typ == "A" {
			x := scanInt()
			y := scanInt()
			curX, curY := x, y
			for curX > 0 {
				k := (curX - 1) / B
				if curX == R[k] {
					d := block_dest[k][curY]
					curX, curY = d.r, d.c
					if curX == -1 || curY == 0 || curY == m+1 {
						break
					}
				} else {
					d := dest[curX][curY]
					curX, curY = d.r, d.c
					if curX == -1 || curY == 0 || curY == m+1 {
						break
					}
				}
			}
			out.WriteString(strconv.Itoa(curX))
			out.WriteByte(' ')
			out.WriteString(strconv.Itoa(curY))
			out.WriteByte('\n')
		} else if typ == "C" {
			x := scanInt()
			y := scanInt()
			c := scanString()
			grid[x][y] = c[0]
			computeDest(x)
			computeBlock((x - 1) / B)
		}
	}
	os.Stdout.WriteString(out.String())
}