```go
package main

import (
	"bufio"
	"os"
)

var P_n_plus_1 int64

type Node struct {
	val  int64
	l, r int32
}

var nodes []Node

func update(node int32, L, R, ql, qr int64, val int64) int32 {
	if ql > R || qr < L {
		return node
	}
	if node == 0 {
		node = int32(len(nodes))
		nodes = append(nodes, Node{val: -1})
	}
	if ql <= L && R <= qr {
		nodes[node].val = val
		nodes[node].l = 0
		nodes[node].r = 0
		return node
	}
	pushdown(node)
	mid := L + (R - L)/2
	nodes[node].l = update(nodes[node].l, L, mid, ql, qr, val)
	nodes[node].r = update(nodes[node].r, mid+1, R, ql, qr, val)
	return node
}

func pushdown(node int32) {
	if nodes[node].val != -1 {
		l := nodes[node].l
		if l == 0 {
			l = int32(len(nodes))
			nodes = append(nodes, Node{val: -1})
			nodes[node].l = l
		}
		r := nodes[node].r
		if r == 0 {
			r = int32(len(nodes))
			nodes = append(nodes, Node{val: -1})
			nodes[node].r = r
		}

		nodes[l].val = nodes[node].val
		nodes[l].l = 0
		nodes[l].r = 0

		nodes[r].val = nodes[node].val
		nodes[r].l = 0
		nodes[r].r = 0

		nodes[node].val = -1
	}
}

func query(node int32, L, R, x int64) int64 {
	if node == 0 {
		return x + P_n_plus_1
	}
	if nodes[node].val != -1 {
		return nodes[node].val
	}
	if L == R {
		return x + P_n_plus_1
	}
	mid := L + (R - L)/2
	if x <= mid {
		return query(nodes[node].l, L, mid, x)
	} else {
		return query(nodes[node].r, mid+1, R, x)
	}
}

func readInt(r *bufio.Reader) int64 {
	var res int64
	b, err := r.ReadByte()
	for err == nil && (b < '0' || b > '9') {
		b, err = r.ReadByte()
	}
	if err != nil {
		return 0
	}
	for err == nil && b >= '0' && b <= '9' {
		res = res*10 + int64(b-'0')
		b, err = r.ReadByte()
	}
	return res
}

func writeInt(w *bufio.Writer, n int64) {
	if n == 0 {
		w.WriteByte('0')
		w.WriteByte('\n')
		return
	}
	var buf [20]byte
	i := 19
	for n > 0 {
		buf[i] = byte(n%10) + '0'
		n /= 10
		i--
	}
	w.Write(buf[i+1:])
	w.WriteByte('\n')
}

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 65536)
	writer := bufio.NewWriterSize(os.Stdout, 65536)
	defer writer.Flush()

	n := int(readInt(reader))
	g := readInt(reader)
	r := readInt(reader)

	l := make([]int64, n+1)
	for i := 0; i <= n; i++ {
		l[i] = readInt(reader)
	}

	q := int(readInt(reader))
	t := make([]int64, q)
	for i := 0; i < q; i++ {
		t[i] = readInt(reader)
	}

	P := make([]int64, n+2)
	for i := 1; i <= n+1; i++ {
		P[i] = P[i-1] + l[i-1]
	}
	P_n_plus_1 = P[n+1]

	c := g + r
	nodes = make([]Node, 1, 5000000)
	nodes[0].val = -1

	var root int32 = 0

	for j := n; j >= 1; j-- {
		y := (-P[j]) % c
		if y < 0 {
			y += c
		}

		val := query(root, 0, c-1, y)

		L1 := y + g - c
		if L1 < 0 {
			L1 = 0
		}
		R1 := y - 1
		if L1 <= R1 {
			root = update(root, 0, c-1, L1, R1, val)
		}

		L2 := y + g
		if L2 > c {
			L2 = c
		}
		R2 := c - 1
		if L2 <= R2 {
			root = update(root, 0, c-1, L2, R2, val+c)
		}
	}

	for i := 0; i < q; i++ {
		x := t[i] % c
		ans := (t[i]/c)*c + query(root, 0, c-1, x)
		writeInt(writer, ans)
	}
}
```