For problem statement at 2000-2999/2100-2199/2110-2119/2111/problemE.txt this is a correct solution, but verifier at 2000-2999/2100-2199/2110-2119/2111/verifierE.go ends with test 4 (random_1) failed on case 2: expected ababbaabaaaabc got aaaabaabacacbc
input:
3
38 10
cbabcbaacccacccabaababaccbbabaacbbcacc
c c
a c
a c
b b
b a
a b
b b
c a
c a
a a
14 9
ababcaabacacbc
a c
a c
c b
b c
b c
a b
c a
c a
b b
4 14
acba
c a
a b
c a
a a
b a
a b
a b
b b
a b
b a
b b
b a
c a
b c
reference output:
aaababaacccacccabaababaccbbabaacbbcacc
ababbaabaaaabc
aaaa

candidate output:
aaababaacccacccabaababaccbbabaacbbcacc
aaaabaabacacbc
aaaa
exit status 1 can you fix the verifier? ```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	fmt.Fscan(in, &t)

	for i := 0; i < t; i++ {
		solve(in, out)
	}
}

func solve(in *bufio.Reader, out *bufio.Writer) {
	var n, q int
	fmt.Fscan(in, &n, &q)

	var sStr string
	fmt.Fscan(in, &sStr)
	s := []byte(sStr)

	type Op struct {
		u, v byte
		id   int
	}
	
	opsBA := []int{}
	opsBC := []int{}
	opsCA := []int{}
	opsCB := []int{}

	for k := 0; k < q; k++ {
		var xStr, yStr string
		fmt.Fscan(in, &xStr, &yStr)
		x := xStr[0]
		y := yStr[0]
		if x == 'b' && y == 'a' {
			opsBA = append(opsBA, k)
		} else if x == 'b' && y == 'c' {
			opsBC = append(opsBC, k)
		} else if x == 'c' && y == 'a' {
			opsCA = append(opsCA, k)
		} else if x == 'c' && y == 'b' {
			opsCB = append(opsCB, k)
		}
	}

	used := make([]bool, q)

	ptrBA, ptrBC, ptrCA, ptrCB := 0, 0, 0, 0

	getBA := func() int {
		for ptrBA < len(opsBA) {
			idx := opsBA[ptrBA]
			if !used[idx] {
				return idx
			}
			ptrBA++
		}
		return -1
	}

	getCA := func() int {
		for ptrCA < len(opsCA) {
			idx := opsCA[ptrCA]
			if !used[idx] {
				return idx
			}
			ptrCA++
		}
		return -1
	}

	getCB := func() int {
		for ptrCB < len(opsCB) {
			idx := opsCB[ptrCB]
			if !used[idx] {
				return idx
			}
			ptrCB++
		}
		return -1
	}

	findChainBCA := func() (int, int) {
		tempBC := ptrBC
		for tempBC < len(opsBC) {
			idx1 := opsBC[tempBC]
			if !used[idx1] {
				k := ptrCA
				for k < len(opsCA) {
					idx2 := opsCA[k]
					if idx2 > idx1 && !used[idx2] {
						return idx1, idx2
					}
					k++
				}
				return -1, -1
			}
			tempBC++
		}
		return -1, -1
	}

	findChainCBA := func() (int, int) {
		tempCB := ptrCB
		for tempCB < len(opsCB) {
			idx1 := opsCB[tempCB]
			if !used[idx1] {
				k := ptrBA
				for k < len(opsBA) {
					idx2 := opsBA[k]
					if idx2 > idx1 && !used[idx2] {
						return idx1, idx2
					}
					k++
				}
				return -1, -1
			}
			tempCB++
		}
		return -1, -1
	}

	for i := 0; i < n; i++ {
		if s[i] == 'a' {
			continue
		} else if s[i] == 'b' {
			idxDirect := getBA()
			if idxDirect != -1 {
				used[idxDirect] = true
				s[i] = 'a'
			} else {
				idx1, idx2 := findChainBCA()
				if idx1 != -1 {
					used[idx1] = true
					used[idx2] = true
					s[i] = 'a'
				}
			}
		} else if s[i] == 'c' {
			idxDirect := getCA()
			if idxDirect != -1 {
				used[idxDirect] = true
				s[i] = 'a'
			} else {
				idx1, idx2 := findChainCBA()
				if idx1 != -1 {
					used[idx1] = true
					used[idx2] = true
					s[i] = 'a'
				} else {
					idxCB := getCB()
					if idxCB != -1 {
						used[idxCB] = true
						s[i] = 'b'
					}
				}
			}
		}
	}
	out.WriteString(string(s) + "\n")
}
```