#include <bits/stdc++.h>

using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, L;
    cin >> n >> L;

    vector<int> x(n);
    for (int i = 0; i < n; ++i) {
        cin >> x[i];
    }
    sort(x.begin(), x.end());

    int q;
    cin >> q;
    vector<int> from(q), to(q), limit(q);
    vector<ll> answer(q, 3e18);
    for (int i = 0; i < q; ++i) {
        cin >> from[i] >> to[i] >> limit[i];
    }

    for (int _ = 0; _ < 2; ++_) {
        vector<ll> pref(n + 1);
        for (int i = 0; i < n; ++i) {
            pref[i + 1] = pref[i] + x[i];
        }
        auto rangeSum = [&](int l, int r) {
            return pref[r] - pref[l];
        };
        auto query = [&](int fin, int mid, int u, int c) -> ll {
            ll now = 0;
//            if (mid == 0 && c == 1) {
//                cout << "here!" << endl;
//            }
            int nx = (mid + 1 < n && x[mid + 1] <= fin ? x[mid + 1] : fin);
            int cord = (c > 0 && u + c - 1 < n ? x[u + c - 1] : fin);
            if (mid >= 0) {
                now += 1LL * fin * (mid + 1) - rangeSum(0, mid + 1);
                now += 1LL * (mid + 1) * 2 * ((fin - nx) + (max(fin, x.back()) - fin) + (cord - fin));
            }
            if (u + c < n) {
                int cnt = (n - u - c);
                now += rangeSum(n - cnt, n) - 1LL * cnt * fin;
                now += 1LL * ((fin - nx) + (cord - fin)) * 2 * cnt;
            }
            if (mid + 1 < u) {
                int cnt = (u - mid - 1);
                now += 1LL * cnt * fin - rangeSum(mid + 1, u);
                now += 1LL * cnt * (cord - fin) * 2;
            }
            if (c > 0) {
                now += rangeSum(u, u + c) - 1LL * c * fin;
            }
            now += fin - x[0] + (u < n ? 2 * (x.back() - fin) : 0) + 2 * (fin - nx) + 2 * (cord - fin);
            return now;
        };
        for (int i = 0; i < q; ++i) {
            int up = upper_bound(x.begin(), x.end(), to[i]) - x.begin();
            int hi = up - 1, lo = -1;
            ll now = 3e18;
            for (int k = lo; k <= hi; ++k) {
                for (int c = 0; c + up <= n; ++c) {
                    now = min(now, query(to[i], k, up, c));
                }
            }
            now += abs(x[0] - from[i]);
//            cout << now << endl;
            auto stupid = [&]() {
                vector<int> p(n);
                iota(p.begin(), p.end(), 0);
                do {
                    int c = from[i], cnt = 1, ans = 0;
                    for (int j = 0; j < n; ++j) {
                        ans += abs(c - x[p[j]]) * cnt;
                        c = x[p[j]];
                        cnt += 1;
                    }
                    ans += abs(c - to[i]) * cnt;
                    if (ans + n <= 187) {
                        cout << ans << endl;
                        for (int r : p) {
                            cout << r << " ";
                        }
                        cout << endl;
                    }
                    answer[i] = min(answer[i], ll(ans));
                } while (next_permutation(p.begin(), p.end()));
            };
//            stupid();
            if (0) {
//                while (lo < hi) {
//                    int mid = lo + hi >> 1;
//                    auto u = query(to[i], mid, up);
//                    auto v = query(to[i], mid + 1, up);
//                    now = min({now, u, v});
//                    if (u < v) {
//                        hi = mid;
//                    } else {
//                        lo = mid + 1;
//                    }
//                }
//                now = min(now, query(to[i], lo, up));
            }
//            cout << "now: " << now << endl;
            answer[i] = min(answer[i], now);
        }
        for (int &t : x) {
            t = L - t;
        }
        for (int i = 0; i < q; ++i) {
            from[i] = L - from[i];
            to[i] = L - to[i];
        }
        reverse(x.begin(), x.end());
    }

    for (int i = 0; i < q; ++i) {
//        cout << answer[i] + n << endl;
        cout << (answer[i] + n <= limit[i] ? "Yes\n" : "No\n");
    }

    return 0;
}