#include <algorithm>
#include <iostream>
#include <queue>
#include <set>
#include <utility>
#include <vector>

int main() {
    using event = std::pair<int, int>;
    using min_queue =
        std::priority_queue<event, std::vector<event>, std::greater<event>>;

    std::cin.tie(nullptr)->sync_with_stdio(false);

    int n, q, s, d;
    std::cin >> n >> q >> s >> d;
    s--;

    std::vector<int> a(n);
    for (int &x : a) std::cin >> x;

    std::vector<int> t(n, -1);
    std::set<int> jump_pos, unseen;
    for (int i = 0; i < n; ++i) unseen.insert(i);

    for (min_queue pq({}, {{0, s}}); !pq.empty();) {
        const auto [tu, u] = pq.top();
        pq.pop();
        if (t[u] != -1) continue;
        t[u] = tu;

        const auto upd = [&, tu = tu](int x) {
            int i = std::lower_bound(a.begin(), a.end(), x) - a.begin();
            auto it = unseen.lower_bound(i);

            if (it != unseen.end()) {
                pq.emplace(std::max(tu, a[*it] - x), *it);
            }
            if (it != unseen.begin()) {
                --it;
                pq.emplace(std::max(tu, x - a[*it]), *it);
            }
        };

        unseen.erase(u);
        auto it = jump_pos.lower_bound(a[u]);
        if (it != jump_pos.end()) upd(*it);
        if (it != jump_pos.begin()) upd(*prev(it));

        for (int p : {a[u] - d, a[u] + d}) {
            jump_pos.insert(p);
            upd(p);
        }
    }

    while (q--) {
        int i, k;
        std::cin >> i >> k;
        i--;

        std::cout << (t[i] <= k ? "Yes" : "No") << "\n";
    }
}
