#include <bits/stdc++.h>
using namespace std;
long long int powm(long long int a, int b, int n) {
  long long int rm = 1;
  while (b) {
    if (b % 2) {
      rm = (rm * a) % n;
    }
    a = (a * a) % n;
    b /= 2;
  }
  return rm;
}
int nxt[int(1e5 + 1000)] = {0}, g, r, tq[int(1e5 + 1000)];
long long int timedp[int(1e5 + 1000)], l[int(1e5 + 1000)], layer;
int seg[4 * int(1e5 + 1000)];
pair<int, int> diff[int(1e5 + 1000)];
int rev[int(1e5 + 1000)];
const long long int ninf = -10000000000000000L;
int mod;
void update(int node, int it, int f, int q, int val) {
  if (it == f) {
    seg[node] = val;
    return;
  }
  int m = (it + f) / 2;
  if (q <= m)
    update(node * 2, it, m, q, val);
  else
    update(node * 2 + 1, m + 1, f, q, val);
  seg[node] = min(seg[node * 2], seg[node * 2 + 1]);
}
int get(int node, int it, int f, int q1, int q2) {
  if (it == q1 && f == q2) return seg[node];
  int m = (it + f) / 2;
  if (q2 <= m)
    return get(node * 2, it, m, q1, q2);
  else if (q1 > m)
    return get(node * 2 + 1, m + 1, f, q1, q2);
  else {
    int val = get(node * 2, it, m, q1, m);
    return min(val, get(node * 2 + 1, m + 1, f, m + 1, q2));
  }
}
pair<int, int> go(int n, int l1, int r1) {
  int it = 1, f = n + 1, m;
  while (it != f) {
    m = (it + f) / 2;
    if (diff[m].first >= l1)
      f = m;
    else
      it = m + 1;
  }
  int l1v = f;
  it = 1, f = n + 1;
  while (it != f) {
    m = (it + f) / 2;
    if (diff[m + 1].first <= r1)
      it = m + 1;
    else
      f = m;
  }
  int r1v = f;
  if (r1v < l1v) return make_pair(-1, -1);
  return make_pair(l1v, r1v);
}
void insert(int node, int it, int f) {
  if (it == f) {
    seg[node] = diff[f].second;
    return;
  }
  int m = (it + f) / 2;
  insert(node * 2, it, m);
  insert(node * 2 + 1, m + 1, f);
  seg[node] = min(seg[node * 2], seg[node * 2 + 1]);
}
int main() {
  int n, Q;
  scanf("%d", &n);
  ;
  scanf("%d", &g);
  ;
  scanf("%d", &r);
  ;
  mod = g + r;
  l[0] = 0;
  int val;
  for (int i = int(1); i <= (int)n + 1; i++) {
    scanf("%d", &val);
    ;
    l[i] = val;
    l[i] += l[i - 1];
  }
  layer = 0;
  diff[n + 1] = make_pair(0, n + 1);
  for (int i = n; i >= 1; --i) {
    layer += l[i + 1] - l[i];
    layer %= mod;
    long long int l2 = -layer;
    l2 = (l2 % mod + mod) % mod;
    diff[i] = make_pair((int)l2, i);
  }
  sort(diff + 1, diff + n + 2);
  for (int i = int(1); i <= (int)4 * int(1e5 + 1000) - 1; i++) seg[i] = 1e9;
  for (int i = int(1); i <= (int)n + 1; i++) rev[diff[i].second] = i;
  update(1, 1, n + 1, rev[n + 1], n + 1);
  layer = 0;
  int it, f, m;
  nxt[n + 1] = n + 1;
  timedp[n + 1] = 0;
  for (int i = n; i >= 1; --i) {
    layer += l[i + 1] - l[i];
    layer %= mod;
    update(1, 1, n + 1, rev[i], i);
    int l1 = g + r + (g - layer), r1 = g + r - 1;
    nxt[i] = 1e9;
    if (r1 >= l1) {
      pair<int, int> qu = go(n, l1, r1);
      int l1v = qu.first, r1v = qu.second;
      if (l1v != -1 && diff[l1v].first >= l1 && diff[r1v].first <= r1) {
        nxt[i] = get(1, 1, n + 1, l1v, r1v);
      }
    }
    int l2 = max(0, g - (int)layer), r2 = g + r - 1 - layer;
    pair<int, int> qu = go(n, l2, r2);
    int l2v = qu.first, r2v = qu.second;
    if (l2v != -1 && diff[l2v].first >= l2 && diff[r2v].first <= r2)
      nxt[i] = min(nxt[i], get(1, 1, n + 1, l2v, r2v));
    if (nxt[i] > 2 * n) nxt[i] = n + 1;
    timedp[i] = l[nxt[i]] - l[i];
    if (nxt[i] < n + 1)
      timedp[i] += (r + g - (l[nxt[i]] - l[i]) % mod) + timedp[nxt[i]];
  }
  scanf("%d", &Q);
  ;
  for (int i = int(1); i <= (int)Q; i++) scanf("%d", &tq[i]);
  ;
  layer = 0;
  for (int i = 1; i <= n + 1; ++i) {
    layer += l[i] - l[i - 1];
    diff[i] = make_pair(layer % mod, i);
  }
  sort(diff + 1, diff + n + 2);
  for (int i = int(1); i <= (int)n + 1; i++) rev[diff[i].second] = i;
  insert(1, 1, n + 1);
  int l1v, r1v;
  for (int i = int(1); i <= (int)Q; i++) {
    layer = tq[i] % mod;
    int l1 = g + r + (g - layer), r1 = g + r - 1;
    int nxt2 = 1e9;
    l1v = r1v = 1e9;
    if (r1 >= l1) {
      pair<int, int> qu = go(n, l1, r1);
      l1v = qu.first, r1v = qu.second;
      if (l1v != -1 && diff[l1v].first >= l1 && diff[r1v].first <= r1) {
        nxt2 = get(1, 1, n + 1, l1v, r1v);
      }
    }
    int l2 = max(0, g - (int)layer), r2 = g + r - 1 - layer;
    pair<int, int> qu = go(n, l2, r2);
    int l2v = qu.first, r2v = qu.second;
    if (l2v != -1 && diff[l2v].first >= l2 && diff[r2v].first <= r2)
      nxt2 = min(nxt2, get(1, 1, n + 1, l2v, r2v));
    if (nxt2 > 2 * n) nxt2 = n + 1;
    long long int actual_time = tq[i] + l[nxt2];
    if (nxt2 < n + 1)
      actual_time += (g + r - (l[nxt2] + tq[i]) % mod) + timedp[nxt2];
    printf("%lld\n", actual_time);
  }
  return 0;
}
