```go
package main

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

type pair struct {
	X, Y int64
}

type CostVal struct {
	cost int64
	val  int64
}

func gcd(a, b int64) int64 {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func getDivisors(x int64) []int64 {
	var divs []int64
	for i := int64(1); i*i <= x; i++ {
		if x%i == 0 {
			divs = append(divs, i)
			if i*i != x {
				divs = append(divs, x/i)
			}
		}
	}
	return divs
}

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

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

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

	q := int(nextInt())

	a := make([]int64, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}
	bArr := make([]int64, n)
	for i := 0; i < n; i++ {
		bArr[i] = nextInt()
	}
	c := make([]int64, n)
	for i := 0; i < n; i++ {
		c[i] = nextInt()
	}

	dArr := make([]int64, q)
	for i := 0; i < q; i++ {
		dArr[i] = nextInt()
	}

	divA := getDivisors(a[0])
	divB := getDivisors(bArr[0])
	candsMap := make(map[int64]bool)
	for _, d := range divA {
		candsMap[d] = true
	}
	for _, d := range divB {
		candsMap[d] = true
	}
	var cands []int64
	for d := range candsMap {
		cands = append(cands, d)
	}

	L := (a[0] / gcd(a[0], bArr[0])) * bArr[0]

	uniquePairs := make(map[pair]int64)
	for i := 0; i < n; i++ {
		X := gcd(a[i], L)
		Y := gcd(bArr[i], L)
		uniquePairs[pair{X, Y}] += c[i]
	}

	var V []int64
	for _, g := range cands {
		ok := true
		for p := range uniquePairs {
			if p.X%g != 0 && p.Y%g != 0 {
				ok = false
				break
			}
		}
		if ok {
			V = append(V, g)
		}
	}
	M := len(V)

	uniqueX := make(map[int64]int64)
	uniqueY := make(map[int64]int64)
	for p, cost := range uniquePairs {
		uniqueX[p.X] += cost
		uniqueY[p.Y] += cost
	}

	var uniqueXKeys []int64
	for X := range uniqueX {
		uniqueXKeys = append(uniqueXKeys, X)
	}
	var uniqueYKeys []int64
	for Y := range uniqueY {
		uniqueYKeys = append(uniqueYKeys, Y)
	}

	BadX := make(map[int64][]int)
	for _, X := range uniqueXKeys {
		var bad []int
		for idx, g := range V {
			if X%g != 0 {
				bad = append(bad, idx)
			}
		}
		BadX[X] = bad
	}

	BadY := make(map[int64][]int)
	for _, Y := range uniqueYKeys {
		var bad []int
		for idx, g := range V {
			if Y%g != 0 {
				bad = append(bad, idx)
			}
		}
		BadY[Y] = bad
	}

	CostA := make([]int64, M)
	for _, X := range uniqueXKeys {
		cost := uniqueX[X]
		for _, u := range BadX[X] {
			CostA[u] += cost
		}
	}

	CostB := make([]int64, M)
	for _, Y := range uniqueYKeys {
		cost := uniqueY[Y]
		for _, v := range BadY[Y] {
			CostB[v] += cost
		}
	}

	bsize := (M + 63) / 64
	FailA := make([][]uint64, M)
	FailB := make([][]uint64, M)
	for i := 0; i < M; i++ {
		FailA[i] = make([]uint64, bsize)
		FailB[i] = make([]uint64, bsize)
	}

	for _, X := range uniqueXKeys {
		bad := BadX[X]
		bset := make([]uint64, bsize)
		for _, u := range bad {
			bset[u>>6] |= 1 << (u & 63)
		}
		for _, u := range bad {
			row := FailA[u]
			for k := 0; k < bsize; k++ {
				row[k] |= bset[k]
			}
		}
	}

	for _, Y := range uniqueYKeys {
		bad := BadY[Y]
		bset := make([]uint64, bsize)
		for _, v := range bad {
			bset[v>>6] |= 1 << (v & 63)
		}
		for _, v := range bad {
			row := FailB[v]
			for k := 0; k < bsize; k++ {
				row[k] |= bset[k]
			}
		}
	}

	WAB := make([][]int64, M)
	for i := 0; i < M; i++ {
		WAB[i] = make([]int64, M)
	}
	for p, cost := range uniquePairs {
		badA := BadX[p.X]
		badB := BadY[p.Y]
		for _, u := range badA {
			row := WAB[u]
			for _, v := range badB {
				row[v] += cost
			}
		}
	}

	cvs := make([]CostVal, 0, M*M)
	for i := 0; i < M; i++ {
		uVal := V[i]
		for j := 0; j < M; j++ {
			vVal := V[j]
			if (FailA[i][j>>6] & (1 << (j & 63))) != 0 {
				continue
			}
			if (FailB[i][j>>6] & (1 << (j & 63))) != 0 {
				continue
			}
			cost := CostA[i] + CostB[j] - WAB[i][j]
			cvs = append(cvs, CostVal{cost: cost, val: uVal + vVal})
		}
	}

	sort.Slice(cvs, func(i, j int) bool {
		if cvs[i].cost != cvs[j].cost {
			return cvs[i].cost < cvs[j].cost
		}
		return cvs[i].val > cvs[j].val
	})

	var filtered []CostVal
	maxVal := int64(-1)
	for _, cv := range cvs {
		if cv.val > maxVal {
			maxVal = cv.val
			filtered = append(filtered, CostVal{cost: cv.cost, val: maxVal})
		}
	}

	out := bufio.NewWriter(os.Stdout)
	for i := 0; i < q; i++ {
		d := dArr[i]
		ans := int64(0)
		l, r := 0, len(filtered)-1
		for l <= r {
			mid := (l + r) / 2
			if filtered[mid].cost <= d {
				ans = filtered[mid].val
				l = mid + 1
			} else {
				r = mid - 1
			}
		}
		if i > 0 {
			out.WriteByte(' ')
		}
		fmt.Fprint(out, ans)
	}
	out.WriteByte('\n')
	out.Flush()
}
```