For problem statement at 0-999/200-299/240-249/240/problemF.txt this is a correct solution, but verifier at 0-999/200-299/240-249/240/verifierF.go ends with All 120 tests passed. can you fix the verifier? ```go
package main

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

type SegTree struct {
	n   int
	cnt []int32
	tag []int8
	s   []byte
}

func NewSegTree(s []byte) *SegTree {
	n := len(s)
	st := &SegTree{
		n:   n,
		cnt: make([]int32, 4*n*26),
		tag: make([]int8, 4*n),
		s:   s,
	}
	for i := range st.tag {
		st.tag[i] = -1
	}
	st.build(1, 1, n)
	return st
}

func (st *SegTree) base(node int) int { return (node - 1) * 26 }

func (st *SegTree) build(node, l, r int) {
	if l == r {
		b := st.base(node)
		c := int(st.s[l-1] - 'a')
		st.cnt[b+c] = 1
		return
	}
	mid := (l + r) >> 1
	left := node << 1
	right := left | 1
	st.build(left, l, mid)
	st.build(right, mid+1, r)
	st.pull(node)
}

func (st *SegTree) pull(node int) {
	b := st.base(node)
	left := node << 1
	right := left | 1
	lb := st.base(left)
	rb := st.base(right)
	for i := 0; i < 26; i++ {
		st.cnt[b+i] = st.cnt[lb+i] + st.cnt[rb+i]
	}
}

func (st *SegTree) push(node, l, r int) {
	t := st.tag[node]
	if t == -1 {
		return
	}
	mid := (l + r) >> 1
	left := node << 1
	right := left | 1

	// Left child
	st.tag[left] = t
	lb := st.base(left)
	for i := 0; i < 26; i++ {
		st.cnt[lb+i] = 0
	}
	st.cnt[lb+int(t)] = int32(mid - l + 1)

	// Right child
	st.tag[right] = t
	rb := st.base(right)
	for i := 0; i < 26; i++ {
		st.cnt[rb+i] = 0
	}
	st.cnt[rb+int(t)] = int32(r - mid)

	st.tag[node] = -1
}

func (st *SegTree) update(node, l, r, ql, qr, c int) {
	if ql <= l && r <= qr {
		b := st.base(node)
		for i := 0; i < 26; i++ {
			st.cnt[b+i] = 0
		}
		st.cnt[b+c] = int32(r - l + 1)
		st.tag[node] = int8(c)
		return
	}
	st.push(node, l, r)
	mid := (l + r) >> 1
	left := node << 1
	right := left | 1
	if ql <= mid {
		st.update(left, l, mid, ql, qr, c)
	}
	if qr > mid {
		st.update(right, mid+1, r, ql, qr, c)
	}
	st.pull(node)
}

func (st *SegTree) query(node, l, r, ql, qr int, out []int32) {
	if ql <= l && r <= qr {
		b := st.base(node)
		for i := 0; i < 26; i++ {
			out[i] += st.cnt[b+i]
		}
		return
	}
	st.push(node, l, r)
	mid := (l + r) >> 1
	left := node << 1
	right := left | 1
	if ql <= mid {
		st.query(left, l, mid, ql, qr, out)
	}
	if qr > mid {
		st.query(right, mid+1, r, ql, qr, out)
	}
}

func (st *SegTree) collect(node, l, r int, out []byte) {
	if l == r {
		b := st.base(node)
		for i := 0; i < 26; i++ {
			if st.cnt[b+i] > 0 {
				out[l-1] = byte('a' + i)
				break
			}
		}
		return
	}
	st.push(node, l, r)
	mid := (l + r) >> 1
	left := node << 1
	right := left | 1
	st.collect(left, l, mid, out)
	st.collect(right, mid+1, r, out)
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		n := len(data)
		for idx < n && (data[idx] <= ' ' || data[idx] > '~') {
			idx++
		}
		sign := 1
		if idx < n && data[idx] == '-' {
			sign = -1
			idx++
		}
		val := 0
		for idx < n && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return sign * val
	}
	nextToken := func() []byte {
		n := len(data)
		for idx < n && (data[idx] <= ' ' || data[idx] > '~') {
			idx++
		}
		start := idx
		for idx < n && data[idx] > ' ' && data[idx] <= '~' {
			idx++
		}
		return append([]byte(nil), data[start:idx]...)
	}

	n := nextInt()
	m := nextInt()
	s := nextToken()
	st := NewSegTree(s)

	for i := 0; i < m; i++ {
		l := nextInt()
		r := nextInt()
		if l > r {
			continue
		}
		freq := make([]int32, 26)
		st.query(1, 1, n, l, r, freq)
		oddCount := 0
		oddIdx := -1
		for c := 0; c < 26; c++ {
			if freq[c]&1 == 1 {
				oddCount++
				oddIdx = c
			}
		}
		if oddCount > 1 {
			continue
		}
		left := l
		right := r
		for c := 0; c < 26; c++ {
			k := int(freq[c] / 2)
			if k > 0 {
				st.update(1, 1, n, left, left+k-1, c)
				st.update(1, 1, n, right-k+1, right, c)
				left += k
				right -= k
			}
		}
		if (r-l+1)&1 == 1 && oddIdx != -1 {
			st.update(1, 1, n, left, left, oddIdx)
		}
	}

	res := make([]byte, n)
	st.collect(1, 1, n, res)
	w := bufio.NewWriter(os.Stdout)
	fmt.Fprintln(w, string(res))
	w.Flush()
}
```