```go
package main

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

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 0, 64*1024)
	scanner.Buffer(buf, 1024*1024*10)

	nextInt := func() int {
		if !scanner.Scan() {
			return 0
		}
		var res int
		b := scanner.Bytes()
		for _, ch := range b {
			res = res*10 + int(ch-'0')
		}
		return res
	}

	k := nextInt()
	if k == 0 {
		return
	}
	n := nextInt()
	m := nextInt()

	maxL_O := make(map[int]int)
	P_set := make(map[int]bool)
	P_set[0] = true
	P_set[k] = true

	for i := 0; i < n; i++ {
		l := nextInt()
		r := nextInt()
		if l > maxL_O[r] {
			maxL_O[r] = l
		}
		if l-1 >= 0 {
			P_set[l-1] = true
		}
		if r-1 >= 0 && r-1 <= k {
			P_set[r-1] = true
		}
		if r >= 0 && r <= k {
			P_set[r] = true
		}
	}

	maxL_R := make(map[int]int)
	for i := 0; i < m; i++ {
		l := nextInt()
		r := nextInt()
		if l > maxL_R[r] {
			maxL_R[r] = l
		}
		if l-1 >= 0 {
			P_set[l-1] = true
		}
		if r-1 >= 0 && r-1 <= k {
			P_set[r-1] = true
		}
		if r >= 0 && r <= k {
			P_set[r] = true
		}
	}

	P := make([]int, 0, len(P_set))
	for p := range P_set {
		if p <= k {
			P = append(P, p)
		}
	}
	sort.Ints(P)

	idx := make(map[int]int)
	for i, p := range P {
		idx[p] = i
	}

	reqO := make([]int, len(P))
	reqR := make([]int, len(P))
	curO := 0
	curR := 0
	for i, p := range P {
		if val, ok := maxL_O[p]; ok {
			if val > curO {
				curO = val
			}
		}
		reqO[i] = curO

		if val, ok := maxL_R[p]; ok {
			if val > curR {
				curR = val
			}
		}
		reqR[i] = curR
	}

	MOD := int64(1000000007)
	S_O := make([]int64, len(P))
	S_R := make([]int64, len(P))

	S_O[0] = 1
	S_R[0] = 1

	var ans int64 = 0

	for i := 0; i < len(P)-1; i++ {
		r_O := reqO[i+1]
		r_R := reqR[i+1]

		var C_R int64 = 0
		if r_O > 0 {
			C_R = S_O[idx[r_O-1]]
		}

		var C_O int64 = 0
		if r_R > 0 {
			C_O = S_R[idx[r_R-1]]
		}

		val_O := (S_R[i] - C_O) % MOD
		if val_O < 0 {
			val_O += MOD
		}

		val_R := (S_O[i] - C_R) % MOD
		if val_R < 0 {
			val_R += MOD
		}

		Lint := P[i+1] - P[i]
		W := (val_O + val_R) % MOD

		ans = (W * power(2, Lint-1)) % MOD

		if Lint == 1 {
			S_O[i+1] = (S_O[i] + val_O) % MOD
			S_R[i+1] = (S_R[i] + val_R) % MOD
		} else {
			p_val := (power(2, Lint-1) - 1 + MOD) % MOD
			delta := (W * p_val) % MOD
			S_O[i+1] = (S_O[i] + val_O + delta) % MOD
			S_R[i+1] = (S_R[i] + val_R + delta) % MOD
		}
	}

	fmt.Println(ans)
}
```