For problem statement at 1000-1999/1100-1199/1120-1129/1120/problemF.txt this is a correct solution, but verifier at 1000-1999/1100-1199/1120-1129/1120/verifierF.go ends with Mismatch on test 1: expected 13, got 18
Input:
5 1 4
0 P
1 W
3 P
5 P
8 P
10

exit status 1 can you fix the verifier? ```go
package main

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

const INF int64 = 1e17

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	var c, d int64
	fmt.Fscan(reader, &n, &c, &d)

	var dp0 int64 = 0
	dpW := make([]int64, 1, n+5)
	dpP := make([]int64, 1, n+5)
	
	dpW[0] = 0 // Dummy element
	dpP[0] = 0 // Dummy element

	var lazyW_C, lazyW_d int64
	var lazyP_C, lazyP_d int64

	W_opt := 1
	P_opt := 1

	var last_t int64 = 0

	pruneW := func() {
		for len(dpW) > 1 {
			last := len(dpW) - 1
			val := dpW[last]
			prev := dp0
			if last > 1 {
				prev = dpW[last-1]
			}
			if val >= prev {
				dpW = dpW[:last]
			} else {
				break
			}
		}
	}

	pruneP := func() {
		for len(dpP) > 1 {
			last := len(dpP) - 1
			val := dpP[last]
			prev := dp0
			if last > 1 {
				prev = dpP[last-1]
			}
			if val >= prev {
				dpP = dpP[:last]
			} else {
				break
			}
		}
	}

	getM_W := func() int64 {
		if len(dpW) <= 1 {
			return INF
		}
		for W_opt > 1 {
			val1 := dpW[W_opt-1] + int64(W_opt-1)*lazyW_C + lazyW_d
			val2 := dpW[W_opt] + int64(W_opt)*lazyW_C + lazyW_d
			if val1 <= val2 {
				W_opt--
			} else {
				break
			}
		}
		return dpW[W_opt] + int64(W_opt)*lazyW_C + lazyW_d
	}

	getM_P := func() int64 {
		if len(dpP) <= 1 {
			return INF
		}
		for P_opt > 1 {
			val1 := dpP[P_opt-1] + int64(P_opt-1)*lazyP_C + lazyP_d
			val2 := dpP[P_opt] + int64(P_opt)*lazyP_C + lazyP_d
			if val1 <= val2 {
				P_opt--
			} else {
				break
			}
		}
		return dpP[P_opt] + int64(P_opt)*lazyP_C + lazyP_d
	}

	for i := 0; i < n; i++ {
		var t int64
		var pStr string
		fmt.Fscan(reader, &t, &pStr)

		C := c * (t - last_t)
		last_t = t

		if pStr == "W" {
			if lazyW_C > 0 || lazyW_d > 0 {
				for k := 1; k < len(dpW); k++ {
					dpW[k] += int64(k)*lazyW_C + lazyW_d
				}
				lazyW_C = 0
				lazyW_d = 0
			}

			for k := 1; k < len(dpW); k++ {
				dpW[k] += int64(k) * C
			}
			pruneW()

			lazyP_C += C
			if P_opt >= len(dpP) { P_opt = len(dpP) - 1 }
			if P_opt < 1 { P_opt = 1 }
			M := getM_P()
			lazyP_d += d

			K := 0
			left, right := 1, len(dpW)-1
			for left <= right {
				mid := (left + right) / 2
				val_mid := dpW[mid]
				prev := dp0
				if mid > 1 {
					prev = dpW[mid-1]
				}

				if val_mid+d <= prev {
					K = mid
					left = mid + 1
				} else {
					right = mid - 1
				}
			}

			valK := dp0
			if K > 0 {
				valK = dpW[K]
			}

			dpW = append(dpW, 0)
			copy(dpW[K+2:], dpW[K+1:len(dpW)-1])
			dpW[K+1] = valK

			for k := 1; k <= K; k++ {
				dpW[k] += d
			}

			new_dp0 := dp0 + d
			if M < dpW[1] {
				dpW[1] = M
			}
			dp0 = new_dp0

			pruneW()
			if W_opt >= len(dpW) { W_opt = len(dpW) - 1 }
			if W_opt < 1 { W_opt = 1 }

		} else {
			if lazyP_C > 0 || lazyP_d > 0 {
				for k := 1; k < len(dpP); k++ {
					dpP[k] += int64(k)*lazyP_C + lazyP_d
				}
				lazyP_C = 0
				lazyP_d = 0
			}

			for k := 1; k < len(dpP); k++ {
				dpP[k] += int64(k) * C
			}
			pruneP()

			lazyW_C += C
			if W_opt >= len(dpW) { W_opt = len(dpW) - 1 }
			if W_opt < 1 { W_opt = 1 }
			M := getM_W()
			lazyW_d += d

			K := 0
			left, right := 1, len(dpP)-1
			for left <= right {
				mid := (left + right) / 2
				val_mid := dpP[mid]
				prev := dp0
				if mid > 1 {
					prev = dpP[mid-1]
				}

				if val_mid+d <= prev {
					K = mid
					left = mid + 1
				} else {
					right = mid - 1
				}
			}

			valK := dp0
			if K > 0 {
				valK = dpP[K]
			}

			dpP = append(dpP, 0)
			copy(dpP[K+2:], dpP[K+1:len(dpP)-1])
			dpP[K+1] = valK

			for k := 1; k <= K; k++ {
				dpP[k] += d
			}

			new_dp0 := dp0 + d
			if M < dpP[1] {
				dpP[1] = M
			}
			dp0 = new_dp0

			pruneP()
			if P_opt >= len(dpP) { P_opt = len(dpP) - 1 }
			if P_opt < 1 { P_opt = 1 }
		}
	}

	var t_n_plus_1 int64
	fmt.Fscan(reader, &t_n_plus_1)
	
	final_C := c * (t_n_plus_1 - last_t)
	ans := dp0

	lazyP_C += final_C
	if P_opt >= len(dpP) { P_opt = len(dpP) - 1 }
	if P_opt < 1 { P_opt = 1 }
	M_P := getM_P()
	if M_P < ans {
		ans = M_P
	}

	lazyW_C += final_C
	if W_opt >= len(dpW) { W_opt = len(dpW) - 1 }
	if W_opt < 1 { W_opt = 1 }
	M_W := getM_W()
	if M_W < ans {
		ans = M_W
	}

	fmt.Println(ans)
}
```