```go
package main

import (
	"bufio"
	"io"
	"os"
	"sort"
)

const INF int64 = 1 << 60

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	b, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: b, n: len(b)}
}

func (fs *FastScanner) NextInt() int {
	s := 1
	v := 0
	// skip non-numeric
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if (c >= '0' && c <= '9') || c == '-' {
			break
		}
		fs.idx++
	}
	if fs.idx < fs.n && fs.data[fs.idx] == '-' {
		s = -1
		fs.idx++
	}
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		v = v*10 + int(c-'0')
		fs.idx++
	}
	return v * s
}

type Fenwick struct {
	n   int
	bit []int
}

func NewFenwick(n int) *Fenwick {
	return &Fenwick{n: n, bit: make([]int, n+2)}
}

func (f *Fenwick) Add(i, delta int) {
	i++
	for i <= f.n {
		f.bit[i] += delta
		i += i & -i
	}
}

func (f *Fenwick) Sum(i int) int {
	i++
	s := 0
	for i > 0 {
		s += f.bit[i]
		i -= i & -i
	}
	return s
}

func (f *Fenwick) Kth(k int) int {
	idx := 0
	bitMask := 1
	for bitMask < f.n {
		bitMask <<= 1
	}
	for step := bitMask; step != 0; step >>= 1 {
		next := idx + step
		if next <= f.n && f.bit[next] < k {
			k -= f.bit[next]
			idx = next
		}
	}
	return idx
}

func lowerBound(a []int64, x int64) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] < x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func computeNext(base []int64, prev []int64, banned [][]int) []int64 {
	nPrev := len(prev)
	nCurr := len(base)

	vals := make([]int64, nPrev)
	copy(vals, prev)
	sort.Slice(vals, func(i, j int) bool { return vals[i] < vals[j] })
	uniq := make([]int64, 0, len(vals))
	for i, v := range vals {
		if i == 0 || v != vals[i-1] {
			uniq = append(uniq, v)
		}
	}

	idxPrev := make([]int, nPrev)
	for i := 0; i < nPrev; i++ {
		idxPrev[i] = lowerBound(uniq, prev[i])
	}

	fw := NewFenwick(len(uniq))
	for i := 0; i < nPrev; i++ {
		fw.Add(idxPrev[i], 1)
	}
	total := nPrev

	res := make([]int64, nCurr)
	for i := 0; i < nCurr; i++ {
		for _, p := range banned[i] {
			fw.Add(idxPrev[p], -1)
			total--
		}
		if total == 0 {
			res[i] = INF
		} else {
			minIdx := fw.Kth(1)
			minVal := uniq[minIdx]
			if minVal >= INF/2 {
				res[i] = INF
			} else {
				sum := base[i] + minVal
				if sum >= INF {
					sum = INF
				}
				res[i] = sum
			}
		}
		for _, p := range banned[i] {
			fw.Add(idxPrev[p], 1)
			total++
		}
	}
	return res
}

func main() {
	fs := NewFastScanner()
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	n1 := fs.NextInt()
	n2 := fs.NextInt()
	n3 := fs.NextInt()
	n4 := fs.NextInt()

	a := make([]int64, n1)
	for i := 0; i < n1; i++ {
		a[i] = int64(fs.NextInt())
	}
	b := make([]int64, n2)
	for i := 0; i < n2; i++ {
		b[i] = int64(fs.NextInt())
	}
	c := make([]int64, n3)
	for i := 0; i < n3; i++ {
		c[i] = int64(fs.NextInt())
	}
	d := make([]int64, n4)
	for i := 0; i < n4; i++ {
		d[i] = int64(fs.NextInt())
	}

	m1 := fs.NextInt()
	bad12 := make([][]int, n2)
	for i := 0; i < m1; i++ {
		x := fs.NextInt() - 1
		y := fs.NextInt() - 1
		bad12[y] = append(bad12[y], x)
	}

	m2 := fs.NextInt()
	bad23 := make([][]int, n3)
	for i := 0; i < m2; i++ {
		x := fs.NextInt() - 1
		y := fs.NextInt() - 1
		bad23[y] = append(bad23[y], x)
	}

	m3 := fs.NextInt()
	bad34 := make([][]int, n4)
	for i := 0; i < m3; i++ {
		x := fs.NextInt() - 1
		y := fs.NextInt() - 1
		bad34[y] = append(bad34[y], x)
	}

	dp1 := a
	dp2 := computeNext(b, dp1, bad12)
	dp3 := computeNext(c, dp2, bad23)
	dp4 := computeNext(d, dp3, bad34)

	ans := INF
	for _, v := range dp4 {
		if v < ans {
			ans = v
		}
	}
	if ans >= INF/2 {
		out.WriteString("-1\n")
	} else {
		// convert to string without fmt for speed
		buf := make([]byte, 0, 32)
		if ans == 0 {
			buf = append(buf, '0')
		} else {
			x := ans
			neg := false
			if x < 0 {
				neg = true
				x = -x
			}
			tmp := make([]byte, 0, 32)
			for x > 0 {
				tmp = append(tmp, byte('0'+x%10))
				x /= 10
			}
			if neg {
				buf = append(buf, '-')
			}
			for i := len(tmp) - 1; i >= 0; i-- {
				buf = append(buf, tmp[i])
			}
		}
		buf = append(buf, '\n')
		out.Write(buf)
	}
}
```