For problem statement at 0-999/900-999/930-939/930/problemE.txt this is a correct solution, but verifier at 0-999/900-999/930-939/930/verifierE.go ends with test 3 failed: expected 2034 got 894

exit status 1 can you fix the verifier? An efficient Go solution for the problem.

```go
package main

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

const MOD = 1000000007

func qpow(a, b int64) int64 {
	res := int64(1)
	for b > 0 {
		if b&1 != 0 {
			res = (res * a) % MOD
		}
		a = (a * a) % MOD
		b >>= 1
	}
	return res
}

type Block struct {
	start   int64
	count   int64
	baseVal int64
	isGeom  bool
}

func (b *Block) sum() int64 {
	if !b.isGeom {
		return b.baseVal
	}
	term := (qpow(2, b.count) - 1 + MOD) % MOD
	return (b.baseVal * term) % MOD
}

func (b *Block) cutHead(until int64) (int64, bool) {
	if until <= b.start {
		return 0, false
	}
	end := b.start + b.count
	if until >= end {
		return b.sum(), true
	}
	
	removeCount := until - b.start
	
	var removedSum int64
	if !b.isGeom {
		// Should not happen for single value block if start < until < end
		return 0, false
	}
	
	removedSum = (b.baseVal * ((qpow(2, removeCount) - 1 + MOD) % MOD)) % MOD
	
	b.baseVal = (b.baseVal * qpow(2, removeCount)) % MOD
	b.start = until
	b.count -= removeCount
	
	return removedSum, false
}

type Deque struct {
	blocks []Block
	head   int
}

func (d *Deque) push(b Block) {
	d.blocks = append(d.blocks, b)
}

func (d *Deque) popFront(until int64) int64 {
	var sumRemoved int64
	for d.head < len(d.blocks) {
		b := &d.blocks[d.head]
		s, empty := b.cutHead(until)
		sumRemoved = (sumRemoved + s) % MOD
		if empty {
			d.head++
		} else {
			break
		}
	}
	return sumRemoved
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var k int64
	var n, m int
	fmt.Fscan(reader, &k, &n, &m)

	maxLA := make(map[int64]int64)
	maxLK := make(map[int64]int64)
	events := make(map[int64]bool)
	events[k] = true

	for i := 0; i < n; i++ {
		var l, r int64
		fmt.Fscan(reader, &l, &r)
		if l > maxLA[r] {
			maxLA[r] = l
		}
		events[r] = true
	}
	for i := 0; i < m; i++ {
		var l, r int64
		fmt.Fscan(reader, &l, &r)
		if l > maxLK[r] {
			maxLK[r] = l
		}
		events[r] = true
	}

	sortedEvents := make([]int64, 0, len(events))
	for e := range events {
		sortedEvents = append(sortedEvents, e)
	}
	sort.Slice(sortedEvents, func(i, j int) bool { return sortedEvents[i] < sortedEvents[j] })

	f := &Deque{}
	g := &Deque{}
	
	// Initial state for pos=1
	f.push(Block{start: 0, count: 1, baseVal: 1, isGeom: false})
	g.push(Block{start: 0, count: 1, baseVal: 1, isGeom: false})
	
	Sf := int64(1)
	Sg := int64(1)
	
	// Apply filters for pos=1
	mK1 := maxLK[1]
	mA1 := maxLA[1]
	
	remF := f.popFront(mK1)
	Sf = (Sf - remF + MOD) % MOD
	
	remG := g.popFront(mA1)
	Sg = (Sg - remG + MOD) % MOD
	
	pos := int64(1)

	for _, target := range sortedEvents {
		if target == 1 {
			continue
		}
		
		lenGap := target - pos - 1
		
		if lenGap > 0 {
			// Step pos+1: add single block
			newF_val := Sg
			newG_val := Sf
			
			f.push(Block{start: pos, count: 1, baseVal: newF_val, isGeom: false})
			g.push(Block{start: pos, count: 1, baseVal: newG_val, isGeom: false})
			
			Sf = (Sf + newF_val) % MOD
			Sg = (Sg + newG_val) % MOD
			
			// Steps pos+2 ... target-1: geometric block
			rem := lenGap - 1
			if rem > 0 {
				total := (Sf + Sg) % MOD
				
				f.push(Block{start: pos + 1, count: rem, baseVal: total, isGeom: true})
				g.push(Block{start: pos + 1, count: rem, baseVal: total, isGeom: true})
				
				geomSum := (total * ((qpow(2, rem) - 1 + MOD) % MOD)) % MOD
				Sf = (Sf + geomSum) % MOD
				Sg = (Sg + geomSum) % MOD
			}
		}
		
		// Handle target
		// 1. Calculate potential values
		val_f := Sg
		val_g := Sf
		
		// 2. Filter
		mA := maxLA[target]
		mK := maxLK[target]
		
		remF := f.popFront(mK)
		Sf = (Sf - remF + MOD) % MOD
		
		remG := g.popFront(mA)
		Sg = (Sg - remG + MOD) % MOD
		
		// 3. Validate and Append
		idx := target - 1
		if idx < mK {
			val_f = 0
		}
		if idx < mA {
			val_g = 0
		}
		
		f.push(Block{start: idx, count: 1, baseVal: val_f, isGeom: false})
		g.push(Block{start: idx, count: 1, baseVal: val_g, isGeom: false})
		
		Sf = (Sf + val_f) % MOD
		Sg = (Sg + val_g) % MOD
		
		pos = target
	}
	
	ans := (Sf + Sg) % MOD
	fmt.Println(ans)
}
```