For problem statement at 0-999/0-99/0-9/2/problemC.txt this is a correct solution, but verifier at 0-999/0-99/0-9/2/verifierC.go ends with Test 3 failed:
input:
242 -927 596
395 -676 442
307 -195 823

expected:

got:
164.63155 -615.17813

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

import (
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
	"strings"
)

func main() {
	data, err := io.ReadAll(os.Stdin)
	if err != nil {
		return
	}
	s := strings.ReplaceAll(string(data), ",", " ")
	tokens := strings.Fields(s)
	if len(tokens) < 9 {
		return
	}
	x1, _ := strconv.ParseFloat(tokens[0], 64)
	y1, _ := strconv.ParseFloat(tokens[1], 64)
	r1, _ := strconv.ParseFloat(tokens[2], 64)
	x2, _ := strconv.ParseFloat(tokens[3], 64)
	y2, _ := strconv.ParseFloat(tokens[4], 64)
	r2, _ := strconv.ParseFloat(tokens[5], 64)
	x3, _ := strconv.ParseFloat(tokens[6], 64)
	y3, _ := strconv.ParseFloat(tokens[7], 64)
	r3, _ := strconv.ParseFloat(tokens[8], 64)

	if r1 == r2 && r2 == r3 {
		B1 := -2 * (x1 - x2)
		C1 := -2 * (y1 - y2)
		D1 := x1*x1 + y1*y1 - (x2*x2 + y2*y2)

		B2 := -2 * (x2 - x3)
		C2 := -2 * (y2 - y3)
		D2 := x2*x2 + y2*y2 - (x3*x3 + y3*y3)

		det := B1*C2 - B2*C1
		if math.Abs(det) > 1e-9 {
			X := (C1*D2 - C2*D1) / det
			Y := (D1*B2 - D2*B1) / det
			fmt.Printf("%.5f %.5f\n", X, Y)
		}
		return
	}

	alpha := r3*r3 - r2*r2
	beta := r1*r1 - r3*r3
	gamma := r2*r2 - r1*r1

	U := 2.0 * (alpha*x1 + beta*x2 + gamma*x3)
	V := 2.0 * (alpha*y1 + beta*y2 + gamma*y3)
	W := -(alpha*(x1*x1 + y1*y1) + beta*(x2*x2 + y2*y2) + gamma*(x3*x3 + y3*y3))

	A12 := r2*r2 - r1*r1
	B12 := -2 * (r2*r2*x1 - r1*r1*x2)
	C12 := -2 * (r2*r2*y1 - r1*r1*y2)
	D12 := r2*r2*(x1*x1 + y1*y1) - r1*r1*(x2*x2 + y2*y2)

	A23 := r3*r3 - r2*r2
	B23 := -2 * (r3*r3*x2 - r2*r2*x3)
	C23 := -2 * (r3*r3*y2 - r2*r2*y3)
	D23 := r3*r3*(x2*x2 + y2*y2) - r2*r2*(x3*x3 + y3*y3)

	A31 := r1*r1 - r3*r3
	B31 := -2 * (r1*r1*x3 - r3*r3*x1)
	C31 := -2 * (r1*r1*y3 - r3*r3*y1)
	D31 := r1*r1*(x3*x3 + y3*y3) - r3*r3*(x1*x1 + y1*y1)

	var A, B, C, D float64
	if math.Abs(A12) >= math.Abs(A23) && math.Abs(A12) >= math.Abs(A31) {
		A, B, C, D = A12, B12, C12, D12
	} else if math.Abs(A23) >= math.Abs(A12) && math.Abs(A23) >= math.Abs(A31) {
		A, B, C, D = A23, B23, C23, D23
	} else {
		A, B, C, D = A31, B31, C31, D31
	}

	var a, b, c float64
	var solveX bool
	if math.Abs(V) >= math.Abs(U) {
		solveX = true
		m := -U / V
		k := -W / V
		a = A * (1 + m*m)
		b = A*2*m*k + B + C*m
		c = A*k*k + C*k + D
	} else {
		solveX = false
		m := -V / U
		k := -W / U
		a = A * (1 + m*m)
		b = A*2*m*k + B*m + C
		c = A*k*k + B*k + D
	}

	delta := b*b - 4*a*c
	maxVal := math.Max(b*b, math.Abs(4*a*c))
	eps := 1e-10 * maxVal
	if delta < -eps {
		return
	}
	if delta < 0 {
		delta = 0
	}

	root1 := (-b + math.Sqrt(delta)) / (2 * a)
	root2 := (-b - math.Sqrt(delta)) / (2 * a)

	var cands [][2]float64
	if solveX {
		m := -U / V
		k := -W / V
		cands = append(cands, [2]float64{root1, m*root1 + k})
		cands = append(cands, [2]float64{root2, m*root2 + k})
	} else {
		m := -V / U
		k := -W / U
		cands = append(cands, [2]float64{m*root1 + k, root1})
		cands = append(cands, [2]float64{m*root2 + k, root2})
	}

	bestRatio := math.MaxFloat64
	var bestCand [2]float64
	found := false

	for _, cand := range cands {
		cx, cy := cand[0], cand[1]
		dist1 := math.Sqrt((cx-x1)*(cx-x1) + (cy-y1)*(cy-y1))
		dist2 := math.Sqrt((cx-x2)*(cx-x2) + (cy-y2)*(cy-y2))
		dist3 := math.Sqrt((cx-x3)*(cx-x3) + (cy-y3)*(cy-y3))

		ratio1 := dist1 / r1
		ratio2 := dist2 / r2
		ratio3 := dist3 / r3

		if math.Abs(ratio1-ratio2) > 1e-4*math.Max(1.0, ratio1) || math.Abs(ratio1-ratio3) > 1e-4*math.Max(1.0, ratio1) {
			continue
		}

		if ratio1 < bestRatio {
			bestRatio = ratio1
			bestCand = cand
			found = true
		}
	}

	if found {
		fmt.Printf("%.5f %.5f\n", bestCand[0], bestCand[1])
	}
}
```