//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,sse,sse2,sse3,ssse3,sse4,abm,popcnt,mmx")
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef double db;
typedef long double ldb;
typedef complex<double> cd;

constexpr ll INF64 = 2'000'000'000'000'000'000, MOD = 1'000'000'007;
constexpr db PI = acos(-1);
constexpr bool IS_FILE = false, IS_TEST_CASES = false;

random_device rd;
mt19937 rnd32(rd());
mt19937_64 rnd64(rd());

template<typename T>
bool assign_max(T& a, T b) {
        if (b > a) {
                a = b;
                return true;
        }
        return false;
}

template<typename T>
bool assign_min(T& a, T b) {
        if (b < a) {
                a = b;
                return true;
        }
        return false;
}

template<typename T>
T square(T a) {
        return a * a;
}

template<>
struct std::hash<pair<ll, ll>> {
        ll operator() (pair<ll, ll> p) const {
                return ((__int128)p.first * MOD + p.second) % INF64;
        }
};

struct Node {
        ll tree, ms, madd, maddp;
        ll l, r;
        Node *nl = nullptr, *nr = nullptr;
        Node(ll l, ll r): l(l), r(r) {
                tree = 0;
                ms = -1;
                madd = 0;
                maddp = 0;
        }
        void make_sons() {
                if (nl != nullptr) {
                        return;
                }
                ll mid = (l + r) / 2;
                nl = new Node(l, mid);
                nr = new Node(mid, r);
        }
        void set(ll x) {
                if (x == -1) {
                        return;
                }
                tree = x * (r - l);
                madd = 0;
                maddp = 0;
                ms = x;
        }
        void add(ll x) {
                tree += x * (r - l);
                madd += x;
        }
        void addp(ll x) {
                tree += x * (r - l) * (r - l - 1) / 2;
                maddp += x;
        }
        void push() {
                make_sons();
                ll mid = (l + r) / 2;
                nl->set(ms);
                nr->set(ms);
                ms = -1;
                nl->add(madd);
                nr->add(madd);
                madd = 0;
                nr->add(maddp * (mid - l));
                nl->addp(maddp);
                nr->addp(maddp);
                maddp = 0;
        }
        ll get(ll x) {
                if (x < l || r <= x) {
                        return 0;
                }
                if (r - l == 1) {
                        return tree;
                }
                push();
                return nl->get(x) + nr->get(x);
        }
        void set(ll ql, ll qr, ll x) {
                if (ql <= l && r <= qr) {
                        set(x);
                        return;
                }
                if (qr <= l || r <= ql) {
                        return;
                }
                push();
                nl->set(ql, qr, x);
                nr->set(ql, qr, x);
                tree = nl->tree + nr->tree;
        }
        void add(ll ql, ll qr, ll x) {
                if (ql <= l && r <= qr) {
                        add(x);
                        return;
                }
                if (qr <= l || r <= ql) {
                        return;
                }
                push();
                nl->add(ql, qr, x);
                nr->add(ql, qr, x);
                tree = nl->tree + nr->tree;
        }
        void addp(ll ql, ll qr, ll x, ll st) {
                if (ql <= l && r <= qr) {
                        add(st);
                        addp(x);
                        return;
                }
                if (qr <= l || r <= ql) {
                        return;
                }
                push();
                ll mid = (l + r) / 2;
                nl->addp(ql, qr, x, st);
                if (ql <= mid) {
                        st += (mid - max(l, ql)) * x;
                }
                nr->addp(ql, qr, x, st);
                tree = nl->tree + nr->tree;
        }
};

struct segment_tree {
        Node *root;
        segment_tree(ll n) {
                root = new Node(0, n);
        }
        ll get(ll x) {
                return root->get(x);
        }
        void set(ll l, ll r, ll x) {
                root->set(l, r, x);
        }
        void add(ll l, ll r, ll x) {
                root->add(l, r, x);
        }
        void addp(ll l, ll r, ll x, ll st = 0) {
                root->addp(l, r, x, st);
        }
};

void solve() {
        ll n, q, d, a, b;
        cin >> n >> q >> d >> a >> b;
        ll cp = min(a * d, b);
        ll cph = b - cp;
        vector<pair<ll, ll>> segs(n);
        map<ll, vector<tuple<ll, ll, ll>>> m;
        for (ll i = 0; i < n; i++) {
                cin >> segs[i].first >> segs[i].second;
                ll b1 = segs[i].first / d, b2 = segs[i].second / d;
                if (b1 == b2) {
                        m[b1].emplace_back(0, segs[i].first % d, segs[i].second % d);
                        m[b1 + 1].emplace_back(1, q, 0);
                        m[b1 + 2].emplace_back(1, q, 0);
                }
                if (b1 + 1 == b2) {
                        m[b1].emplace_back(0, segs[i].first % d, d - 1);
                        m[b2].emplace_back(0, 0, segs[i].second % d);
                        m[b2 + 2].emplace_back(1, q, 0);
                        m[b2 + 1].emplace_back(1, q, 0);
                }
                if (b1 + 1 < b2) {
                        m[b1].emplace_back(0, segs[i].first % d, d - 1);
                        m[b1 + 1].emplace_back(0, 0, d - 1);
                }
        }
        vector<ll> ans(q + 1, -1);
        vector<ll> qqq(q);
        for (ll i = 0; i < q; i++) {
                ll x;
                cin >> x;
                qqq[i] = x;
                m[x / d].emplace_back(1, i, x % d);
        }
        ll lst = 0;
        segment_tree st(d);
        st.set(0, 1, 0);
        st.set(1, d, INF64);
        deque<pair<ll, ll>> zs;
        m[0].emplace_back(1, q, 0);
        zs.emplace_back(1, d - 1);
        ll last = INF64;
        ll pbad = 0;
        while (!m.empty()) {
                auto[now, op] = *m.begin();
                m.erase(m.begin());
                st.add(0, d, (now - lst) * cp);
                lst = now;
                st.add(0, pbad, cph);
                ll bsuff = d;
                deque<pair<ll, ll>> nzs;
                ll npbad = 0;
                sort(op.begin(), op.end());
                for (auto[t, l, r] : op) {
                        if (t != 0) {
                                continue;
                        }
                        assign_min(bsuff, r + 1);
                        assign_max(npbad, l);
                        st.set(l, r + 1, INF64);
                        nzs.emplace_back(l, r);
                }
                st.add(max(pbad, bsuff), d, cph);
                pbad = npbad;
                deque<pair<ll, ll>> nnzs = nzs;
                vector<pair<ll, ll>> rseg;
                deque<pair<ll, ll>> nnnzs;
                ll lst = 0;
                for (auto[l, r] : zs) {
                        if (lst < l) {
                                nnnzs.emplace_back(lst, l - 1);
                        }
                        nnnzs.emplace_back(l, r);
                        lst = r + 1;
                }
                if (lst < d) {
                        nnnzs.emplace_back(lst, d - 1);
                }
                zs = nnnzs;
                while (!zs.empty()) {
                        auto[l, r] = zs.front();
                        zs.pop_front();
                        while (!nnzs.empty() && nnzs.front().first <= r) {
                                auto[nl, nr] = nnzs.front();
                                nnzs.pop_front();
                                if (nr < l) {
                                        continue;
                                }
                                if (nl > l) {
                                        rseg.emplace_back(l, nl - 1);
                                }
                                if (nr > r) {
                                        nnzs.emplace_front(r + 1, nr);
                                }
                                l = nr + 1;
                        }
                        if (l <= r) {
                                rseg.emplace_back(l, r);
                        }
                }
                for (auto[l, r] : rseg) {
                        ll fe = (l == 0 ? last : st.get(l - 1));
                        ll nst = st.get(l);
                        if (nst >= INF64 && fe >= INF64) {
                                nzs.emplace_back(l, r);
                        } else {
                                if ((nst >= INF64) || (fe + a <= nst && cph > 0)) {
                                        st.set(l, r + 1, fe + a);
                                        st.addp(l, r + 1, a);
                                }
                        }
                }
                sort(nzs.begin(), nzs.end());
                for (auto[t, l, r] : op) {
                        if (t != 1) {
                                continue;
                        }
                        ans[l] = st.get(r);
                }
                zs = nzs;
                last = st.get(d - 1);
        }
        for (ll i = 0; i < q; i++) {
                if (ans[i] >= INF64) {
                        ans[i] = -1;
                } else {
                        //ans[i] = qqq[i];
                }
                cout << ans[i] << '\n';
        }
}

int main() {
        if (IS_FILE) {
                freopen("", "r", stdin);
                freopen("", "w", stdout);
        }
        ios_base::sync_with_stdio(false);
        cin.tie(0);
        cout.tie(0);
        ll t = 1;
        if (IS_TEST_CASES) {
                cin >> t;
        }
        for (ll i = 0; i < t; i++) {
                solve();
        }
}