For problem statement at 0-999/300-399/360-369/363/problemD.txt this is a correct solution, but verifier at 0-999/300-399/360-369/363/verifierD.go ends with case 19 failed: expected 3 105 got 2 28
exit status 1 can you fix the verifier? ```go
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, m int
	var a int64
	fmt.Fscan(reader, &n, &m, &a)

	b := make([]int64, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &b[i])
	}

	p := make([]int64, m)
	for i := 0; i < m; i++ {
		fmt.Fscan(reader, &p[i])
	}

	sort.Slice(b, func(i, j int) bool { return b[i] > b[j] })
	sort.Slice(p, func(i, j int) bool { return p[i] < p[j] })

	// Binary search on the number of boys k that can rent bikes
	// For a given k, we take the k cheapest bikes and the k richest boys
	// We pair the richest boy with the cheapest bike, etc. to minimize shared budget needed.
	// Wait, actually to minimize the shared budget, we should pair the richest boy with the most expensive bike among the k cheapest.
	// Let me think again.
	
	// For k boys: take k cheapest bikes (p[0..k-1]) and k richest boys (b[0..k-1])
	// To minimize shared budget: pair b[0] (richest) with p[k-1] (most expensive among chosen), 
	// b[1] with p[k-2], etc.
	// The deficit for pair i is max(0, p[k-1-i] - b[i])
	// Total deficit must be <= a

	canRent := func(k int) bool {
		if k == 0 {
			return true
		}
		if k > n || k > m {
			return false
		}
		var need int64
		for i := 0; i < k; i++ {
			diff := p[k-1-i] - b[i]
			if diff > 0 {
				need += diff
				if need > a {
					return false
				}
			}
		}
		return need <= a
	}

	// Binary search for maximum k
	lo, hi := 0, n
	if m < hi {
		hi = m
	}
	for lo < hi {
		mid := (lo + hi + 1) / 2
		if canRent(mid) {
			lo = mid
		} else {
			hi = mid - 1
		}
	}

	maxK := lo

	if maxK == 0 {
		fmt.Fprintln(writer, 0, 0)
		return
	}

	// Now find minimum personal money spent for maxK boys
	// We have maxK boys (richest) and maxK bikes (cheapest)
	// Pairing: b[i] with p[maxK-1-i]
	// Each boy pays min(b[i], p[maxK-1-i]) from personal money, rest from shared
	// Total shared = sum of max(0, p[maxK-1-i] - b[i]) <= a
	// Remaining shared = a - total_needed_shared
	// We can use remaining shared to reduce personal spending
	// Personal spending for boy i = max(0, p[maxK-1-i] - max(0, p[maxK-1-i] - b[i])) 
	// Wait, let me reconsider.
	
	// For each pair, the cost is p[maxK-1-i]. Boy i pays some amount from personal, rest from shared.
	// Boy i personal payment = p[maxK-1-i] - (shared allocated to this boy)
	// But personal payment >= 0 and <= min(b[i], p[maxK-1-i])
	// Minimum personal = max(0, p[maxK-1-i] - shared_for_i)
	// We want to minimize sum of personal = sum of p[maxK-1-i] - sum of shared allocated
	// Subject to: shared allocated to boy i <= p[maxK-1-i], total shared <= a
	// Also shared to boy i <= p[maxK-1-i] (can't pay more than price)
	// And personal >= 0 means shared_i <= p[maxK-1-i]
	// Also personal <= b[i] means shared_i >= p[maxK-1-i] - b[i]
	
	// So minimize total personal = sum(p[maxK-1-i]) - min(sum(shared_i), a) where each shared_i <= p[maxK-1-i] and shared_i >= max(0, p[maxK-1-i]-b[i])
	
	totalCost := int64(0)
	totalDeficit := int64(0)
	for i := 0; i < maxK; i++ {
		price := p[maxK-1-i]
		totalCost += price
		diff := price - b[i]
		if diff > 0 {
			totalDeficit += diff
		}
	}

	remaining := a - totalDeficit
	// We can use remaining to further offset personal money, but limited by each boy's personal contribution
	// Max we can offset in total is min(remaining, sum of min(b[i], p[maxK-1-i]))
	totalPersonal := totalCost - totalDeficit - remaining
	if totalPersonal < 0 {
		totalPersonal = 0
	}

	fmt.Fprintln(writer, maxK, totalPersonal)
}
```