For problem statement at 1000-1999/1800-1899/1880-1889/1889/problemC2.txt this is a correct solution, but verifier at 1000-1999/1800-1899/1880-1889/1889/verifierC2.go ends with case 2 failed: expected 5 got 6
input:
1
6 1 1
3 3
exit status 1 can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
	"math/bits"
)

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var t int
	fmt.Fscan(in, &t)
	for cas := 0; cas < t; cas++ {
		var n, m, k int
		fmt.Fscan(in, &n, &m, &k)
		type Interval struct {
			l, r int
		}
		intervals := make([]Interval, m)
		for i := 0; i < m; i++ {
			fmt.Fscan(in, &intervals[i].l, &intervals[i].r)
		}
		type Event struct {
			pos     int
			id      int
			isStart bool
		}
		events := []Event{}
		for i := 0; i < m; i++ {
			events = append(events, Event{intervals[i].l, i, true})
			if intervals[i].r+1 <= n+1 {
				events = append(events, Event{intervals[i].r + 1, i, false})
			}
		}
		sort.Slice(events, func(i, j int) bool {
			if events[i].pos != events[j].pos {
				return events[i].pos < events[j].pos
			}
			return !events[i].isStart && events[j].isStart
		})
		active := make(map[int]struct{})
		current_pos := 1
		mp := make(map[string]int64)
		ei := 0
		for ; ei < len(events); {
			next_pos := events[ei].pos
			len1 := next_pos - current_pos
			if len1 > 0 {
				count := len(active)
				if count <= k {
					v := []int{}
					for id1 := range active {
						v = append(v, id1)
					}
					sort.Ints(v)
					var sb strings.Builder
					for j, x := range v {
						if j > 0 {
							sb.WriteString(",")
						}
						sb.WriteString(strconv.Itoa(x))
					}
					key := sb.String()
					mp[key] += int64(len1)
				}
			}
			current_pos = next_pos
			for ; ei < len(events) && events[ei].pos == current_pos; ei++ {
				e := events[ei]
				if e.isStart {
					active[e.id] = struct{}{}
				} else {
					delete(active, e.id)
				}
			}
		}
		len1 := n - current_pos + 1
		if len1 > 0 {
			count := len(active)
			if count <= k {
				v := []int{}
				for id1 := range active {
					v = append(v, id1)
				}
				sort.Ints(v)
				var sb strings.Builder
				for j, x := range v {
					if j > 0 {
						sb.WriteString(",")
					}
					sb.WriteString(strconv.Itoa(x))
				}
				key := sb.String()
				mp[key] += int64(len1)
			}
		}
		w_empty := mp[""]
		sets := [][]int{}
		ww := []int64{}
		for key, val := range mp {
			if key == "" {
				continue
			}
			strs := strings.Split(key, ",")
			v := []int{}
			for _, s := range strs {
				x, _ := strconv.Atoi(s)
				v = append(v, x)
			}
			sets = append(sets, v)
			ww = append(ww, val)
		}
		daySet := make(map[int]struct{})
		for _, v := range sets {
			for _, x := range v {
				daySet[x] = struct{}{}
			}
		}
		alldays := []int{}
		for d := range daySet {
			alldays = append(alldays, d)
		}
		sort.Ints(alldays)
		r := len(alldays)
		idm := make(map[int]int)
		for j := 0; j < r; j++ {
			idm[alldays[j]] = j
		}
		setMasks := []int{}
		for _, v := range sets {
			mask := 0
			for _, x := range v {
				mask |= (1 << idm[x])
			}
			setMasks = append(setMasks, mask)
		}
		adj := make([][]int, r)
		for q := 0; q < len(sets); q++ {
			v := sets[q]
			for a := 0; a < len(v); a++ {
				for b := a + 1; b < len(v); b++ {
					u := idm[v[a]]
					vv := idm[v[b]]
					adj[u] = append(adj[u], vv)
					adj[vv] = append(adj[vv], u)
				}
			}
		}
		visited := make([]bool, r)
		components := [][]int{}
		for i := 0; i < r; i++ {
			if !visited[i] {
				comp := []int{}
				stack := []int{i}
				visited[i] = true
				for len(stack) > 0 {
					cur := stack[len(stack)-1]
					stack = stack[:len(stack)-1]
					comp = append(comp, cur)
					for _, to := range adj[cur] {
						if !visited[to] {
							visited[to] = true
							stack = append(stack, to)
						}
					}
				}
				components = append(components, comp)
			}
		}
		dpm := make([]int64, k+1)
		for j := 0; j <= k; j++ {
			dpm[j] = 0
		}
		for _, comp := range components {
			s := len(comp)
			localId := make([]int, r)
			for j := 0; j < r; j++ {
				localId[j] = -1
			}
			for j := 0; j < s; j++ {
				localId[comp[j]] = j
			}
			localContrib := make([]int64, 1<<uint(s))
			for q := 0; q < len(sets); q++ {
				ok := true
				lmask := 0
				for _, x := range sets[q] {
					lid := localId[idm[x]]
					if lid == -1 {
						ok = false
						break
					}
					lmask |= (1 << uint(lid))
				}
				if ok {
					localContrib[lmask] += ww[q]
				}
			}
			for bit := 0; bit < s; bit++ {
				for mask := 0; mask < (1<<uint(s)); mask++ {
					if (mask & (1 << uint(bit))) != 0 {
						localContrib[mask] += localContrib[mask^(1<<uint(bit))]
					}
				}
			}
			localMax := make([]int64, s+1)
			for mask := 0; mask < (1<<uint(s)); mask++ {
				pop := bits.OnesCount(uint(mask))
				localMax[pop] = max(localMax[pop], localContrib[mask])
			}
			newDp := make([]int64, k+1)
			copy(newDp, dpm)
			for j := 0; j <= k; j++ {
				for c := 0; c <= s && j+c <= k; c++ {
					newDp[j+c] = max(newDp[j+c], dpm[j]+localMax[c])
				}
			}
			dpm = newDp
		}
		var maxAdd int64 = 0
		for j := 0; j <= k; j++ {
			maxAdd = max(maxAdd, dpm[j])
		}
		ans := w_empty + maxAdd
		fmt.Println(ans)
	}
}
```