For problem statement at 0-999/0-99/30-39/33/problemE.txt this is a correct solution, but verifier at 0-999/0-99/30-39/33/verifierE.go ends with All tests passed can you fix the verifier? ```go
package main

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

type Job struct {
	student int
	p       int
	d       int
	w       int
}

func parseTime(s string) int {
	p := strings.IndexByte(s, ':')
	h, _ := strconv.Atoi(s[:p])
	m, _ := strconv.Atoi(s[p+1:])
	return h*60 + m
}

func parseSegment(s string) (int, int) {
	p := strings.IndexByte(s, '-')
	return parseTime(s[:p]), parseTime(s[p+1:])
}

func markBusy(busy []bool, l, r int) {
	if l <= r {
		for i := l; i <= r; i++ {
			busy[i] = true
		}
	} else {
		for i := l; i < 1440; i++ {
			busy[i] = true
		}
		for i := 0; i <= r; i++ {
			busy[i] = true
		}
	}
}

func formatTime(x int) string {
	return fmt.Sprintf("%02d:%02d", x/60, x%60)
}

func main() {
	in := bufio.NewReader(os.Stdin)

	var m, n, k int
	if _, err := fmt.Fscan(in, &m, &n, &k); err != nil {
		return
	}

	subjects := make([]string, m)
	for i := 0; i < m; i++ {
		fmt.Fscan(in, &subjects[i])
	}

	durations := make([]int, m)
	for i := 0; i < m; i++ {
		fmt.Fscan(in, &durations[i])
	}

	subjDur := make(map[string]int, m)
	for i := 0; i < m; i++ {
		subjDur[subjects[i]] = durations[i]
	}

	busy := make([]bool, 1440)
	for i := 0; i < 4; i++ {
		var seg string
		fmt.Fscan(in, &seg)
		l, r := parseSegment(seg)
		markBusy(busy, l, r)
	}

	totalMinutes := k * 1440
	prefix := make([]int, totalMinutes+1)
	availAbs := make([]int, 0, totalMinutes)
	for t := 0; t < totalMinutes; t++ {
		if !busy[t%1440] {
			prefix[t+1] = prefix[t] + 1
			availAbs = append(availAbs, t)
		} else {
			prefix[t+1] = prefix[t]
		}
	}

	jobs := make([]Job, 0, n)
	for i := 1; i <= n; i++ {
		var s, timeStr string
		var day, cost int
		fmt.Fscan(in, &s, &day, &timeStr, &cost)

		p, ok := subjDur[s]
		if !ok || cost <= 0 {
			continue
		}

		absExam := (day-1)*1440 + parseTime(timeStr)
		d := prefix[absExam]
		if p <= d {
			jobs = append(jobs, Job{student: i, p: p, d: d, w: cost})
		}
	}

	sort.Slice(jobs, func(i, j int) bool {
		if jobs[i].d != jobs[j].d {
			return jobs[i].d < jobs[j].d
		}
		if jobs[i].student != jobs[j].student {
			return jobs[i].student < jobs[j].student
		}
		return jobs[i].p < jobs[j].p
	})

	q := len(jobs)
	maxD := 0
	for _, job := range jobs {
		if job.d > maxD {
			maxD = job.d
		}
	}

	dp := make([][]int, q+1)
	dp[0] = make([]int, maxD+1)
	for t := 1; t <= maxD; t++ {
		dp[0][t] = -1
	}

	for i := 1; i <= q; i++ {
		prev := dp[i-1]
		cur := make([]int, maxD+1)
		copy(cur, prev)
		job := jobs[i-1]
		for t := job.p; t <= job.d; t++ {
			if prev[t-job.p] != -1 {
				val := prev[t-job.p] + job.w
				if val > cur[t] {
					cur[t] = val
				}
			}
		}
		dp[i] = cur
	}

	bestProfit := 0
	bestT := 0
	for t := 0; t <= maxD; t++ {
		if dp[q][t] > bestProfit {
			bestProfit = dp[q][t]
			bestT = t
		}
	}

	selected := make([]Job, 0)
	t := bestT
	for i := q; i >= 1; i-- {
		if dp[i][t] != dp[i-1][t] {
			selected = append(selected, jobs[i-1])
			t -= jobs[i-1].p
		}
	}

	for i, j := 0, len(selected)-1; i < j; i, j = i+1, j-1 {
		selected[i], selected[j] = selected[j], selected[i]
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	fmt.Fprintln(out, bestProfit)
	fmt.Fprintln(out, len(selected))

	curWork := 0
	for _, job := range selected {
		startAbs := availAbs[curWork]
		finishAbs := availAbs[curWork+job.p-1]

		startDay := startAbs/1440 + 1
		finishDay := finishAbs/1440 + 1

		fmt.Fprintf(out, "%d %d %s %d %s\n",
			job.student,
			startDay, formatTime(startAbs%1440),
			finishDay, formatTime(finishAbs%1440),
		)

		curWork += job.p
	}
}
```