```go
package main

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

const MOD = 1000000007

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

type Interval struct {
	l, r int
}

func getValue(x int, E []int, arr []int64) int64 {
	if x == -1 {
		return 0
	}
	idx := sort.SearchInts(E, x)
	if idx < len(E) && E[idx] == x {
		return arr[idx]
	}
	return 0
}

var rdr *bufio.Reader = bufio.NewReaderSize(os.Stdin, 65536)

func readInt() int {
	var n int
	var c byte
	for {
		c, _ = rdr.ReadByte()
		if c >= '0' && c <= '9' {
			n = int(c - '0')
			break
		}
	}
	for {
		c, _ = rdr.ReadByte()
		if c >= '0' && c <= '9' {
			n = n*10 + int(c-'0')
		} else {
			break
		}
	}
	return n
}

func main() {
	k := readInt()
	n := readInt()
	m := readInt()

	A := make([]Interval, n)
	for i := 0; i < n; i++ {
		A[i] = Interval{readInt(), readInt()}
	}
	B := make([]Interval, m)
	for i := 0; i < m; i++ {
		B[i] = Interval{readInt(), readInt()}
	}

	E_temp := make([]int, 0, 2+2*n+2*m)
	E_temp = append(E_temp, 0, k)
	for _, iv := range A {
		E_temp = append(E_temp, iv.l-1, iv.r)
	}
	for _, iv := range B {
		E_temp = append(E_temp, iv.l-1, iv.r)
	}

	sort.Ints(E_temp)

	E_uniq := make([]int, 0, len(E_temp))
	last := -1
	for _, val := range E_temp {
		if val != last && val >= 0 && val <= k {
			E_uniq = append(E_uniq, val)
			last = val
		}
	}

	E_temp2 := make([]int, 0, 2*len(E_uniq))
	for _, val := range E_uniq {
		E_temp2 = append(E_temp2, val)
		if val > 0 {
			E_temp2 = append(E_temp2, val-1)
		}
	}

	sort.Ints(E_temp2)

	E := make([]int, 0, len(E_temp2))
	last = -1
	for _, val := range E_temp2 {
		if val != last && val >= 0 && val <= k {
			E = append(E, val)
			last = val
		}
	}

	sort.Slice(A, func(i, j int) bool { return A[i].r < A[j].r })
	sort.Slice(B, func(i, j int) bool { return B[i].r < B[j].r })

	SO := make([]int64, len(E))
	SR := make([]int64, len(E))

	SO[0] = 1
	SR[0] = 1
	var curS int64 = 2

	idxA := 0
	idxB := 0
	maxLA := 0
	maxLB := 0

	inv2 := int64(500000004)

	for i := 1; i < len(E); i++ {
		x := E[i-1] + 1
		y := E[i]

		for idxA < len(A) && A[idxA].r <= y {
			if A[idxA].l > maxLA {
				maxLA = A[idxA].l
			}
			idxA++
		}
		for idxB < len(B) && B[idxB].r <= y {
			if B[idxB].l > maxLB {
				maxLB = B[idxB].l
			}
			idxB++
		}

		d := int64(y - x + 1)

		CA := getValue(maxLA-1, E, SO)
		CB := getValue(maxLB-1, E, SR)

		C := (CA + CB) % MOD

		term := (curS - C + MOD) % MOD
		nextS := (power(2, d) * term) % MOD
		nextS = (nextS + C) % MOD

		D := (CA - CB + MOD) % MOD

		nextSO := (nextS + D) % MOD
		nextSO = (nextSO * inv2) % MOD

		nextSR := (nextS - D + MOD) % MOD
		nextSR = (nextSR * inv2) % MOD

		SO[i] = nextSO
		SR[i] = nextSR
		curS = nextS
	}

	lastIdx := len(E) - 1
	Sk := (SO[lastIdx] + SR[lastIdx]) % MOD
	Sk_1 := (SO[lastIdx-1] + SR[lastIdx-1]) % MOD
	ans := (Sk - Sk_1 + MOD) % MOD

	fmt.Println(ans)
}
```