```go
package main

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

type Pair struct {
	f, s int
}

type Event struct {
	typ, id int
}

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var t int
	fmt.Fscan(in, &t)
	for _ = range make([]int, t) {
		var n, m, k int
		fmt.Fscan(in, &n, &m, &k)
		l := make([]int, m+1)
		r := make([]int, m+1)
		for i := 1; i <= m; i++ {
			fmt.Fscan(in, &l[i], &r[i])
		}
		diff := make([]int, n+2)
		for i := 1; i <= m; i++ {
			diff[l[i]]++
			diff[r[i]+1]--
		}
		cov := make([]int, n+1)
		cur := 0
		for x := 1; x <= n; x++ {
			cur += diff[x]
			cov[x] = cur
		}
		dry0 := 0
		for x := 1; x <= n; x++ {
			if cov[x] == 0 {
				dry0++
			}
		}
		ones := make([]int, n+1)
		for x := 1; x <= n; x++ {
			if cov[x] == 1 {
				ones[x] = 1
			}
		}
		pref := make([]int, n+2)
		for x := 1; x <= n; x++ {
			pref[x] = pref[x-1] + ones[x]
		}
		alone := make([]int, m+1)
		for i := 1; i <= m; i++ {
			alone[i] = pref[r[i]] - pref[l[i]-1]
		}
		events := make([][]Event, n+3)
		for i := 1; i <= m; i++ {
			events[l[i]] = append(events[l[i]], Event{1, i})
			rempos := r[i] + 1
			if rempos < len(events) {
				events[rempos] = append(events[rempos], Event{0, i})
			}
		}
		active := make(map[int]bool)
		sharedm := make(map[Pair]int)
		for pos := 1; pos <= n; pos++ {
			ev := events[pos]
			if len(ev) > 0 {
				sort.Slice(ev, func(i, j int) bool {
					return ev[i].typ < ev[j].typ
				})
				for _, e := range ev {
					if e.typ == 0 {
						delete(active, e.id)
					} else {
						active[e.id] = true
					}
				}
			}
			if cov[pos] == 2 {
				var list []int
				for id := range active {
					list = append(list, id)
				}
				a, b := list[0], list[1]
				if a > b {
					a, b = b, a
				}
				sharedm[Pair{a, b}]++
			}
		}
		alonesl := []int{}
		for i := 1; i <= m; i++ {
			alonesl = append(alonesl, alone[i])
		}
		sort.Sort(sort.Reverse(sort.IntSlice(alonesl)))
		maxdef := 0
		if len(alonesl) >= 2 {
			maxdef = alonesl[0] + alonesl[1]
		}
		emax := 0
		for k, v := range sharedm {
			p := k.f
			q := k.s
			temp := alone[p] + alone[q] + v
			if temp > emax {
				emax = temp
			}
		}
		add := max(maxdef, emax)
		fmt.Println(dry0 + add)
	}
}
```