```go
package main

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

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

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

func readInt(in *bufio.Reader) int {
	n := 0
	c, err := in.ReadByte()
	for err == nil && c <= ' ' {
		c, err = in.ReadByte()
	}
	for err == nil && c > ' ' {
		n = n*10 + int(c-'0')
		c, err = in.ReadByte()
	}
	return n
}

func readInt64(in *bufio.Reader) int64 {
	var n int64 = 0
	c, err := in.ReadByte()
	for err == nil && c <= ' ' {
		c, err = in.ReadByte()
	}
	for err == nil && c > ' ' {
		n = n*10 + int64(c-'0')
		c, err = in.ReadByte()
	}
	return n
}

type Item struct {
	a, b int
	c    int64
}

type CostPair struct {
	sum  int
	cost int64
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	n := readInt(in)
	if n == 0 {
		return
	}
	q := readInt(in)

	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = readInt(in)
	}
	b := make([]int, n)
	for i := 0; i < n; i++ {
		b[i] = readInt(in)
	}
	c := make([]int64, n)
	var W int64
	for i := 0; i < n; i++ {
		c[i] = readInt64(in)
		W += c[i]
	}
	queries := make([]int64, q)
	for i := 0; i < q; i++ {
		queries[i] = readInt64(in)
	}

	items := make([]Item, n)
	for i := 0; i < n; i++ {
		items[i] = Item{a[i], b[i], c[i]}
	}
	sort.Slice(items, func(i, j int) bool {
		if items[i].a != items[j].a {
			return items[i].a < items[j].a
		}
		return items[i].b < items[j].b
	})

	var uniqueItems []Item
	for i := 0; i < n; i++ {
		if i == 0 || items[i].a != items[i-1].a || items[i].b != items[i-1].b {
			uniqueItems = append(uniqueItems, items[i])
		} else {
			uniqueItems[len(uniqueItems)-1].c += items[i].c
		}
	}

	divsA := getDivisors(a[0])
	divsB := getDivisors(b[0])
	set := make(map[int]bool)
	for _, x := range divsA {
		set[x] = true
	}
	for _, x := range divsB {
		set[x] = true
	}
	var S []int
	for x := range set {
		S = append(S, x)
	}
	sort.Ints(S)

	var V []int
	for _, x := range S {
		valid := true
		for _, item := range uniqueItems {
			if item.a%x != 0 && item.b%x != 0 {
				valid = false
				break
			}
		}
		if valid {
			V = append(V, x)
		}
	}

	reqArr := make([]int, len(V))
	for j, ga := range V {
		req := 0
		for _, item := range uniqueItems {
			if item.a%ga != 0 {
				req = gcd(req, item.a)
			} else if item.b%ga != 0 {
				req = gcd(req, item.b)
			}
			if req == 1 {
				break
			}
		}
		reqArr[j] = req
	}

	H := make([][]int64, len(V))
	for i := range H {
		H[i] = make([]int64, len(V))
	}

	for _, item := range uniqueItems {
		var divA []int
		for j, ga := range V {
			if item.a%ga == 0 {
				divA = append(divA, j)
			}
		}
		var divB []int
		for j, gb := range V {
			if item.b%gb == 0 {
				divB = append(divB, j)
			}
		}
		for _, ga := range divA {
			for _, gb := range divB {
				H[ga][gb] += item.c
			}
		}
	}

	var validPairs []CostPair
	for i, ga := range V {
		req := reqArr[i]
		for j, gb := range V {
			if req%gb == 0 {
				validPairs = append(validPairs, CostPair{
					sum:  ga + gb,
					cost: W - H[i][j],
				})
			}
		}
	}

	sort.Slice(validPairs, func(i, j int) bool {
		return validPairs[i].cost < validPairs[j].cost
	})

	maxSum := 0
	for i := range validPairs {
		if validPairs[i].sum > maxSum {
			maxSum = validPairs[i].sum
		}
		validPairs[i].sum = maxSum
	}

	for i := 0; i < q; i++ {
		d := queries[i]
		l, r := 0, len(validPairs)-1
		ans := 0
		for l <= r {
			mid := (l + r) / 2
			if validPairs[mid].cost <= d {
				ans = validPairs[mid].sum
				l = mid + 1
			} else {
				r = mid - 1
			}
		}
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, ans)
	}
	fmt.Fprintln(out)
}
```