```go
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	nextToken := func() string {
		scanner.Scan()
		return scanner.Text()
	}

	nextInt := func() int {
		s := nextToken()
		v, _ := strconv.Atoi(s)
		return v
	}

	if !scanner.Scan() {
		return
	}
	m, _ := strconv.Atoi(scanner.Text())
	n := nextInt()
	k := nextInt()

	subjects := make([]string, m)
	for i := 0; i < m; i++ {
		subjects[i] = nextToken()
	}

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

	sleep := nextToken()
	breakfast := nextToken()
	lunch := nextToken()
	dinner := nextToken()

	is_work_min := make([]bool, k*1440)
	for i := 0; i < k*1440; i++ {
		is_work_min[i] = true
	}

	intervals := []string{sleep, breakfast, lunch, dinner}
	for _, s := range intervals {
		h1 := int(s[0]-'0')*10 + int(s[1]-'0')
		m1 := int(s[3]-'0')*10 + int(s[4]-'0')
		h2 := int(s[6]-'0')*10 + int(s[7]-'0')
		m2 := int(s[9]-'0')*10 + int(s[10]-'0')
		startM := h1*60 + m1
		endM := h2*60 + m2
		for d := 0; d < k; d++ {
			for m_min := startM; m_min <= endM; m_min++ {
				is_work_min[d*1440+m_min] = false
			}
		}
	}

	work_min_to_abs := make([]int, 0, k*1440)
	for i := 0; i < k*1440; i++ {
		if is_work_min[i] {
			work_min_to_abs = append(work_min_to_abs, i)
		}
	}

	type Job struct {
		id int
		T  int
		D  int
		C  int64
	}

	var jobs []Job
	for i := 1; i <= n; i++ {
		sj := nextToken()
		dj := nextInt()
		timej := nextToken()
		cj := nextInt()

		time_req, ok := t[sj]
		if !ok {
			continue
		}

		h := int(timej[0]-'0')*10 + int(timej[1]-'0')
		m_min := int(timej[3]-'0')*10 + int(timej[4]-'0')
		Ei := (dj-1)*1440 + h*60 + m_min

		Wi := 0
		for _, absM := range work_min_to_abs {
			if absM < Ei {
				Wi++
			} else {
				break
			}
		}

		if time_req <= Wi {
			jobs = append(jobs, Job{
				id: i,
				T:  time_req,
				D:  Wi,
				C:  int64(cj),
			})
		}
	}

	sort.Slice(jobs, func(i, j int) bool {
		return jobs[i].D < jobs[j].D
	})

	W_max := len(work_min_to_abs)
	dp := make([]int64, W_max+1)
	for i := 0; i <= W_max; i++ {
		dp[i] = -1
	}
	dp[0] = 0

	parent := make([][]bool, len(jobs)+1)
	for i := 0; i <= len(jobs); i++ {
		parent[i] = make([]bool, W_max+1)
	}

	for i, job := range jobs {
		for w := job.D; w >= job.T; w-- {
			if dp[w-job.T] != -1 {
				if dp[w-job.T]+job.C > dp[w] {
					dp[w] = dp[w-job.T] + job.C
					parent[i+1][w] = true
				}
			}
		}
	}

	maxProfit := int64(-1)
	bestW := -1
	for w := 0; w <= W_max; w++ {
		if dp[w] > maxProfit {
			maxProfit = dp[w]
			bestW = w
		}
	}

	if maxProfit <= 0 {
		fmt.Println(0)
		fmt.Println(0)
		return
	}

	currW := bestW
	var chosenJobs []Job
	for i := len(jobs); i >= 1; i-- {
		if parent[i][currW] {
			chosenJobs = append(chosenJobs, jobs[i-1])
			currW -= jobs[i-1].T
		}
	}

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

	fmt.Println(maxProfit)
	fmt.Println(len(chosenJobs))

	current_wm := 0
	for _, job := range chosenJobs {
		start_wm := current_wm
		end_wm := current_wm + job.T - 1
		current_wm += job.T

		abs_start := work_min_to_abs[start_wm]
		abs_end := work_min_to_abs[end_wm]

		start_day := abs_start/1440 + 1
		start_rem := abs_start % 1440
		start_h := start_rem / 60
		start_m := start_rem % 60

		end_day := abs_end/1440 + 1
		end_rem := abs_end % 1440
		end_h := end_rem / 60
		end_m := end_rem % 60

		fmt.Printf("%d %d %02d:%02d %d %02d:%02d\n", job.id, start_day, start_h, start_m, end_day, end_h, end_m)
	}
}
```