//#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 - 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);
        }
};

const ll MAXC = 2'000'000;

void solve() {
        ll n, q, d, a, b;
        cin >> n >> q >> d >> a >> b;
        vector<ll> dp(MAXC, INF64);
        for (ll i = 0; i < n; i++) {
                ll l, r;
                cin >> l >> r;
                for (ll j = l; j <= r; j++) {
                        dp[j] = -1;
                }
        }
        dp[0] = 0;
        for (ll i = 0; i < MAXC; i++) {
                if (dp[i] != -1) {
                        if (i + 1 < MAXC) {
                                assign_min(dp[i + 1], dp[i] + a);
                        }
                        if (i + d < MAXC) {
                                assign_min(dp[i + d], dp[i] + b);
                        }
                }
        }
        for (ll i = 0; i < q; i++) {
                ll x;
                cin >> x;
                cout << dp[x] << '\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();
        }
}