For problem statement at 0-999/500-599/590-599/596/problemD.txt this is a correct solution, but verifier at 0-999/500-599/590-599/596/verifierD.go ends with case 1 failed:
expected: 9.24806399999999762
 got: 9.3520320000

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

import (
	"fmt"
	"math"
	"sort"
)

func main() {
	var n, h int
	var p float64
	fmt.Scan(&n, &h, &p)

	x := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&x[i])
	}
	sort.Ints(x)

	R := make([]int, n)
	L := make([]int, n)
	for i := 0; i < n; i++ {
		R[i] = i
		for j := i + 1; j < n && x[j]-x[j-1] < h; j++ {
			R[i] = j
		}
		L[i] = i
		for j := i - 1; j >= 0 && x[j+1]-x[j] < h; j-- {
			L[i] = j
		}
	}

	memo := make([][][][]float64, n)
	for i := 0; i < n; i++ {
		memo[i] = make([][][]float64, n)
		for j := 0; j < n; j++ {
			memo[i][j] = make([][]float64, 2)
			for k := 0; k < 2; k++ {
				memo[i][j][k] = make([]float64, 2)
				for l := 0; l < 2; l++ {
					memo[i][j][k][l] = -1
				}
			}
		}
	}

	var solve func(l, r, sl, sr int) float64
	solve = func(l, r, sl, sr int) float64 {
		if l > r {
			return 0
		}
		if memo[l][r][sl][sr] >= 0 {
			return memo[l][r][sl][sr]
		}

		probL, probR := 0.5, 0.5
		if l == r {
			probL, probR = 1.0, 0.0
		}

		var result float64
		fh := float64(h)

		overlap := 0.0
		if l > 0 {
			dist := float64(x[l] - x[l-1])
			if sl == 0 {
				overlap = math.Max(0, fh-dist)
			} else {
				overlap = math.Max(0, 2*fh-dist)
			}
		}
		result += probL * p * (fh - overlap + solve(l+1, r, 0, sr))

		rEff := R[l]
		if rEff > r {
			rEff = r
		}
		overlap = 0
		if rEff == r && r < n-1 && sr == 1 {
			overlap = math.Max(0, float64(x[r]+h)-float64(x[r+1]-h))
		}
		result += probL * (1 - p) * (float64(x[rEff]+h-x[l]) - overlap + solve(rEff+1, r, 1, sr))

		lEff := L[r]
		if lEff < l {
			lEff = l
		}
		overlap = 0
		if lEff == l && l > 0 {
			dist := float64(x[l] - x[l-1])
			if sl == 0 {
				overlap = math.Max(0, fh-dist)
			} else {
				overlap = math.Max(0, 2*fh-dist)
			}
		}
		result += probR * p * (float64(x[r]-x[lEff]+h) - overlap + solve(l, lEff-1, sl, 1))

		overlap = 0
		if r < n-1 {
			dist := float64(x[r+1] - x[r])
			if sr == 0 {
				overlap = math.Max(0, fh-dist)
			} else {
				overlap = math.Max(0, 2*fh-dist)
			}
		}
		result += probR * (1 - p) * (fh - overlap + solve(l, r-1, sl, 0))

		memo[l][r][sl][sr] = result
		return result
	}

	fmt.Printf("%.10f\n", solve(0, n-1, 0, 0))
}
```