For problem statement at 0-999/900-999/910-919/914/problemF.txt this is a correct solution, but verifier at 0-999/900-999/910-919/914/verifierF.go ends with All tests passed can you fix the verifier? package main

import (
	"io"
	"math/bits"
	"os"
	"strconv"
)

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0

	nextInt := func() int {
		for p < len(data) && data[p] <= ' ' {
			p++
		}
		n := 0
		for p < len(data) && data[p] > ' ' {
			n = n*10 + int(data[p]-'0')
			p++
		}
		return n
	}

	nextToken := func() []byte {
		for p < len(data) && data[p] <= ' ' {
			p++
		}
		start := p
		for p < len(data) && data[p] > ' ' {
			p++
		}
		return data[start:p]
	}

	s := append([]byte(nil), nextToken()...)
	n := len(s)
	wc := (n + 63) >> 6
	lastWord := wc - 1

	var bitsets [26][]uint64
	for i := 0; i < 26; i++ {
		bitsets[i] = make([]uint64, wc)
	}
	for i, ch := range s {
		bitsets[ch-'a'][i>>6] |= uint64(1) << uint(i&63)
	}

	var lowMask, highMask [64]uint64
	all := ^uint64(0)
	for i := 0; i < 64; i++ {
		lowMask[i] = all << uint(i)
		if i == 63 {
			highMask[i] = all
		} else {
			highMask[i] = (uint64(1) << uint(i+1)) - 1
		}
	}

	q := nextInt()
	out := make([]byte, 0, q*4)

	for ; q > 0; q-- {
		t := nextInt()
		if t == 1 {
			pos := nextInt() - 1
			c := nextToken()[0]
			if s[pos] != c {
				oldc := s[pos] - 'a'
				newc := c - 'a'
				mask := uint64(1) << uint(pos&63)
				bitsets[oldc][pos>>6] &^= mask
				bitsets[newc][pos>>6] |= mask
				s[pos] = c
			}
		} else {
			l := nextInt() - 1
			r := nextInt() - 1
			y := nextToken()
			m := len(y)
			R := r - m + 1
			ans := 0

			if R >= l {
				wl := l >> 6
				wr := R >> 6
				maskL := lowMask[l&63]
				maskR := highMask[R&63]

				switch m {
				case 1:
					b0 := bitsets[y[0]-'a']
					for w := wl; w <= wr; w++ {
						cur := b0[w]
						if w == wl {
							cur &= maskL
						}
						if w == wr {
							cur &= maskR
						}
						ans += bits.OnesCount64(cur)
					}
				case 2:
					b0 := bitsets[y[0]-'a']
					b1 := bitsets[y[1]-'a']
					for w := wl; w <= wr; w++ {
						cur := b0[w]
						x1 := b1[w] >> 1
						if w < lastWord {
							x1 |= b1[w+1] << 63
						}
						cur &= x1
						if w == wl {
							cur &= maskL
						}
						if w == wr {
							cur &= maskR
						}
						ans += bits.OnesCount64(cur)
					}
				case 3:
					b0 := bitsets[y[0]-'a']
					b1 := bitsets[y[1]-'a']
					b2 := bitsets[y[2]-'a']
					for w := wl; w <= wr; w++ {
						cur := b0[w]
						x1 := b1[w] >> 1
						x2 := b2[w] >> 2
						if w < lastWord {
							x1 |= b1[w+1] << 63
							x2 |= b2[w+1] << 62
						}
						cur &= x1 & x2
						if w == wl {
							cur &= maskL
						}
						if w == wr {
							cur &= maskR
						}
						ans += bits.OnesCount64(cur)
					}
				case 4:
					b0 := bitsets[y[0]-'a']
					b1 := bitsets[y[1]-'a']
					b2 := bitsets[y[2]-'a']
					b3 := bitsets[y[3]-'a']
					for w := wl; w <= wr; w++ {
						cur := b0[w]
						x1 := b1[w] >> 1
						x2 := b2[w] >> 2
						x3 := b3[w] >> 3
						if w < lastWord {
							x1 |= b1[w+1] << 63
							x2 |= b2[w+1] << 62
							x3 |= b3[w+1] << 61
						}
						cur &= x1 & x2 & x3
						if w == wl {
							cur &= maskL
						}
						if w == wr {
							cur &= maskR
						}
						ans += bits.OnesCount64(cur)
					}
				default:
					b0 := bitsets[y[0]-'a']
					for w := wl; w <= wr; w++ {
						cur := b0[w]
						for j := 1; j < m && cur != 0; j++ {
							bs := bitsets[y[j]-'a']
							k := w + (j >> 6)
							off := uint(j & 63)
							var x uint64
							if k < wc {
								x = bs[k] >> off
								if off != 0 && k < lastWord {
									x |= bs[k+1] << (64 - off)
								}
							}
							cur &= x
						}
						if w == wl {
							cur &= maskL
						}
						if w == wr {
							cur &= maskR
						}
						ans += bits.OnesCount64(cur)
					}
				}
			}

			out = strconv.AppendInt(out, int64(ans), 10)
			out = append(out, '\n')
		}
	}

	os.Stdout.Write(out)
}