For problem statement at 0-999/600-699/630-639/633/problemE.txt this is a correct solution, but verifier at 0-999/600-699/630-639/633/verifierE.go ends with case 1 failed: expected "3.500000\n" got "3.500000000"
input:
4 1
9 8 1 9
9 1 2 2
exit status 1 can you fix the verifier? package main

import (
	"fmt"
	"os"
	"sort"
)

func max32(a, b int32) int32 {
	if a > b {
		return a
	}
	return b
}

func min32(a, b int32) int32 {
	if a < b {
		return a
	}
	return b
}

func main() {
	buf := make([]byte, 1024*1024*64)
	nBytes, _ := os.Stdin.Read(buf)
	pos := 0

	readInt := func() int {
		for pos < nBytes && buf[pos] <= ' ' {
			pos++
		}
		if pos >= nBytes {
			return 0
		}
		res := 0
		for pos < nBytes && buf[pos] > ' ' {
			res = res*10 + int(buf[pos]-'0')
			pos++
		}
		return res
	}

	n := readInt()
	if n == 0 {
		return
	}
	k := readInt()

	v := make([]int32, n)
	for i := 0; i < n; i++ {
		v[i] = int32(readInt() * 100)
	}
	c := make([]int32, n)
	for i := 0; i < n; i++ {
		c[i] = int32(readInt())
	}

	log2 := make([]int, n+1)
	for i := 2; i <= n; i++ {
		log2[i] = log2[i/2] + 1
	}
	K := log2[n] + 1

	stV := make([]int32, n*K)
	stC := make([]int32, n*K)

	for i := 0; i < n; i++ {
		stV[i] = v[i]
		stC[i] = c[i]
	}

	for j := 1; j < K; j++ {
		offset := j * n
		prevOffset := (j - 1) * n
		step := 1 << (j - 1)
		for i := 0; i+(1<<j) <= n; i++ {
			stV[offset+i] = max32(stV[prevOffset+i], stV[prevOffset+i+step])
			stC[offset+i] = min32(stC[prevOffset+i], stC[prevOffset+i+step])
		}
	}

	queryV := func(l, r int) int32 {
		j := log2[r-l+1]
		offset := j * n
		return max32(stV[offset+l], stV[offset+r-(1<<j)+1])
	}

	queryC := func(l, r int) int32 {
		j := log2[r-l+1]
		offset := j * n
		return min32(stC[offset+l], stC[offset+r-(1<<j)+1])
	}

	M := make([]int, n)
	for l := 0; l < n; l++ {
		low, high := l, n-1
		ansR := l - 1
		for low <= high {
			mid := (low + high) / 2
			maxV := queryV(l, mid)
			minC := queryC(l, mid)
			if maxV <= minC {
				ansR = mid
				low = mid + 1
			} else {
				high = mid - 1
			}
		}

		best := int32(0)
		if ansR >= l {
			val := min32(queryV(l, ansR), queryC(l, ansR))
			if val > best {
				best = val
			}
		}
		if ansR+1 < n {
			val := min32(queryV(l, ansR+1), queryC(l, ansR+1))
			if val > best {
				best = val
			}
		}
		M[l] = int(best)
	}

	sort.Ints(M)

	expected := 0.0
	prob := float64(k) / float64(n)
	for i := 0; i <= n-k; i++ {
		expected += float64(M[i]) * prob
		if i < n-k {
			prob = prob * float64(n-i-k) / float64(n-i-1)
		}
	}

	fmt.Printf("%.9f\n", expected)
}