For problem statement at 0-999/800-899/880-889/887/problemE.txt this is a correct solution, but verifier at 0-999/800-899/880-889/887/verifierE.go ends with case 1 failed: expected 415.24329 got 15.50000
exit status 1 can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"io"
	"math"
	"math/bits"
	"os"
	"sort"
)

type U128 struct {
	hi uint64
	lo uint64
}

type Interval struct {
	l float64
	r float64
}

const two64 = 18446744073709551616.0

func mulU(a, b uint64) U128 {
	hi, lo := bits.Mul64(a, b)
	return U128{hi: hi, lo: lo}
}

func cmpU(a, b U128) int {
	if a.hi < b.hi {
		return -1
	}
	if a.hi > b.hi {
		return 1
	}
	if a.lo < b.lo {
		return -1
	}
	if a.lo > b.lo {
		return 1
	}
	return 0
}

func subU(a, b U128) U128 {
	lo, borrow := bits.Sub64(a.lo, b.lo, 0)
	hi, _ := bits.Sub64(a.hi, b.hi, borrow)
	return U128{hi: hi, lo: lo}
}

func shlU(a U128, k uint) U128 {
	if k == 0 {
		return a
	}
	if k < 64 {
		return U128{
			hi: (a.hi << k) | (a.lo >> (64 - k)),
			lo: a.lo << k,
		}
	}
	if k < 128 {
		return U128{
			hi: a.lo << (k - 64),
			lo: 0,
		}
	}
	return U128{}
}

func toFloatU(a U128) float64 {
	return float64(a.hi)*two64 + float64(a.lo)
}

func abs64(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int64 {
		for idx < len(data) {
			c := data[idx]
			if c == ' ' || c == '\n' || c == '\r' || c == '\t' {
				idx++
			} else {
				break
			}
		}
		sign := int64(1)
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		var val int64
		for idx < len(data) {
			c := data[idx]
			if c < '0' || c > '9' {
				break
			}
			val = val*10 + int64(c-'0')
			idx++
		}
		return sign * val
	}

	x1 := nextInt()
	y1 := nextInt()
	x2 := nextInt()
	y2 := nextInt()

	n := int(nextInt())

	dx := x2 - x1
	dy := y2 - y1
	D := dx*dx + dy*dy
	Df := float64(D)
	sqrtD := math.Sqrt(Df)
	a2 := Df / 4.0

	intervals := make([]Interval, 0, n)

	for i := 0; i < n; i++ {
		xi := nextInt()
		yi := nextInt()
		ri := nextInt()

		s := dx*(yi-y1) - dy*(xi-x1)
		sAbs := uint64(abs64(s))
		r2 := uint64(ri) * uint64(ri)

		s2 := mulU(sAbs, sAbs)
		r2D := mulU(r2, uint64(D))
		Nu := subU(s2, r2D)
		Nf := toFloatU(Nu)

		tx := 2*xi - x1 - x2
		ty := 2*yi - y1 - y2
		K4 := tx*tx + ty*ty - D - 4*ri*ri
		K := float64(K4) / 4.0

		kAbs := uint64(abs64(K4))
		K4sq := mulU(kAbs, kAbs)
		sixteenR2D := shlU(r2D, 4)

		var Cf float64
		if cmpU(K4sq, sixteenR2D) >= 0 {
			Cf = toFloatU(subU(K4sq, sixteenR2D)) / 64.0
		} else {
			Cf = -toFloatU(subU(sixteenR2D, K4sq)) / 64.0
		}

		A := Nf / Df
		B := -K * float64(s) / sqrtD
		sqrtDisc := float64(ri) * math.Sqrt(K*K+Nf)

		var q float64
		if B >= 0 {
			q = -0.5 * (B + sqrtDisc)
		} else {
			q = -0.5 * (B - sqrtDisc)
		}

		r1 := q / A
		r2f := Cf / q
		if r1 > r2f {
			r1, r2f = r2f, r1
		}
		intervals = append(intervals, Interval{l: r1, r: r2f})
	}

	sort.Slice(intervals, func(i, j int) bool {
		if intervals[i].l == intervals[j].l {
			return intervals[i].r < intervals[j].r
		}
		return intervals[i].l < intervals[j].l
	})

	bestT := 0.0
	covered := false

	for i := 0; i < len(intervals); {
		L := intervals[i].l
		R := intervals[i].r
		i++
		for i < len(intervals) && intervals[i].l < R {
			if intervals[i].r > R {
				R = intervals[i].r
			}
			i++
		}
		if L < 0 && 0 < R {
			covered = true
			if -L < R {
				bestT = -L
			} else {
				bestT = R
			}
			break
		}
		if L > 0 {
			break
		}
	}

	ans := sqrtD / 2.0
	if covered {
		ans = math.Sqrt(a2 + bestT*bestT)
	}

	out := bufio.NewWriter(os.Stdout)
	fmt.Fprintf(out, "%.15f\n", ans)
	out.Flush()
}
```