```go
package main

import (
	"bytes"
	"io"
	"os"
	"sort"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
}

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

func (fs *FastScanner) NextInt() int64 {
	n := len(fs.data)
	for fs.idx < n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := int64(1)
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var val int64
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int64(c-'0')
		fs.idx++
	}
	return val * sign
}

type Fenwick struct {
	n   int
	bit []int
}

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

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

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

type SegTree struct {
	n    int
	tree []int
}

func NewSegTree(m int) *SegTree {
	n := 1
	for n < m {
		n <<= 1
	}
	return &SegTree{n: n, tree: make([]int, 2*n)}
}

func (s *SegTree) Update(pos, val int) {
	i := pos + s.n
	if s.tree[i] >= val {
		return
	}
	s.tree[i] = val
	for i >>= 1; i > 0; i >>= 1 {
		v := s.tree[i<<1]
		if s.tree[i<<1|1] > v {
			v = s.tree[i<<1|1]
		}
		if s.tree[i] == v {
			break
		}
		s.tree[i] = v
	}
}

func (s *SegTree) Query(l, r int) int {
	if l > r {
		return 0
	}
	l += s.n
	r += s.n
	res := 0
	for l <= r {
		if l&1 == 1 {
			if s.tree[l] > res {
				res = s.tree[l]
			}
			l++
		}
		if r&1 == 0 {
			if s.tree[r] > res {
				res = s.tree[r]
			}
			r--
		}
		l >>= 1
		r >>= 1
	}
	return res
}

type Query struct {
	t  int64
	l  int64
	r  int64
	id int
}

func lowerBound(a []int64, x int64) int {
	return sort.Search(len(a), func(i int) bool { return a[i] >= x })
}

func upperBound(a []int64, x int64) int {
	return sort.Search(len(a), func(i int) bool { return a[i] > x })
}

func max64(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}

func main() {
	fs := NewFastScanner()

	n := int(fs.NextInt())
	k := fs.NextInt()

	r := make([]int64, n)
	for i := 0; i < n; i++ {
		r[i] = fs.NextInt()
	}

	a := make([]int64, n)
	ages := make([]int64, n)
	for i := 0; i < n; i++ {
		a[i] = fs.NextInt()
		ages[i] = a[i]
	}

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

	m := len(uniq)
	agePos := make([]int, n)
	for i := 0; i < n; i++ {
		agePos[i] = lowerBound(uniq, a[i])
	}

	orderAsc := make([]int, n)
	for i := 0; i < n; i++ {
		orderAsc[i] = i
	}
	sort.Slice(orderAsc, func(i, j int) bool {
		return r[orderAsc[i]] < r[orderAsc[j]]
	})

	g := make([]int, n)
	fenwick := NewFenwick(m)

	for l := 0; l < n; {
		rr := l + 1
		cur := r[orderAsc[l]]
		for rr < n && r[orderAsc[rr]] == cur {
			rr++
		}
		for i := l; i < rr; i++ {
			idx := orderAsc[i]
			fenwick.Add(agePos[idx]+1, 1)
		}
		for i := l; i < rr; i++ {
			idx := orderAsc[i]
			left := lowerBound(uniq, a[idx]-k) + 1
			right := upperBound(uniq, a[idx]+k)
			g[idx] = fenwick.Sum(right) - fenwick.Sum(left-1)
		}
		l = rr
	}

	q := int(fs.NextInt())
	ans := make([]int, q)
	queries := make([]Query, 0, q)

	for i := 0; i < q; i++ {
		x := int(fs.NextInt()) - 1
		y := int(fs.NextInt()) - 1

		left := max64(a[x], a[y]) - k
		right := min64(a[x], a[y]) + k
		if left > right {
			ans[i] = -1
			continue
		}
		t := max64(r[x], r[y])
		queries = append(queries, Query{t: t, l: left, r: right, id: i})
	}

	sort.Slice(queries, func(i, j int) bool {
		return queries[i].t > queries[j].t
	})

	orderDesc := make([]int, n)
	for i := 0; i < n; i++ {
		orderDesc[i] = i
	}
	sort.Slice(orderDesc, func(i, j int) bool {
		return r[orderDesc[i]] > r[orderDesc[j]]
	})

	seg := NewSegTree(m)
	ptr := 0

	for _, qu := range queries {
		for ptr < n && r[orderDesc[ptr]] >= qu.t {
			idx := orderDesc[ptr]
			seg.Update(agePos[idx], g[idx])
			ptr++
		}
		l := lowerBound(uniq, qu.l)
		rr := upperBound(uniq, qu.r) - 1
		if l > rr {
			ans[qu.id] = -1
			continue
		}
		res := seg.Query(l, rr)
		if res == 0 {
			ans[qu.id] = -1
		} else {
			ans[qu.id] = res
		}
	}

	var out bytes.Buffer
	for i := 0; i < q; i++ {
		out.WriteString(strconv.Itoa(ans[i]))
		out.WriteByte('\n')
	}
	_, _ = os.Stdout.Write(out.Bytes())
}
```