#include <iostream>
#include <bits/stdc++.h>


using namespace std;
#define ull unsigned long long

struct whatever {
    int start;
    int end;
    int index;


};



int compare_1(const whatever& a, const whatever& b){
    return (a.end - a.start) < (b.end - b.start);
}

int compare_2(const whatever a, const whatever& b){
    return a.index < b.index;
}



void solve() {
    // TODO SEGMENT TREE ???

    int nFreq, nQueries;
    cin >> nFreq >> nQueries;
    vector<int> frequencies(nFreq);
    map<int, int> subArrays;
    multimap<int, int> failures;
    vector<whatever> indexedQueries;
    vector<bool> output(nQueries);

    for (int i = 0; i < nFreq; i++){
        cin >> frequencies[i];
    }
    for (int query = 0; query < nQueries; query++) {
        int start, end;
        cin >> start;
        cin >> end;
        start -= 1;
        end -= 1;
        indexedQueries.push_back({start, end, query});
    }
    std::sort(indexedQueries.begin(), indexedQueries.end(), compare_1);

    for (auto& indexedQuery: indexedQueries) {
        bool isValid = false;
        bool shouldContinue = true;
        for (int pos = indexedQuery.start; pos <= indexedQuery.end; pos++){
            auto foundFailures = failures.find(pos);
            while (foundFailures != failures.end()) {
                if (foundFailures->second < indexedQuery.end) {
                    shouldContinue = false;
                    output[indexedQuery.index] = false;
                    break;
                }
                foundFailures++;
            }
        }
        if (!shouldContinue) {
            continue;
        }
        for (int pos = indexedQuery.start; pos >= 0; pos--) {
            if (subArrays.find(pos) != subArrays.end()) {
                int currentSubArrayEnd = subArrays[pos];
                int newSubArrayEnd = currentSubArrayEnd;
                if (currentSubArrayEnd < indexedQuery.end) {
                    for (int j = currentSubArrayEnd + 1; j <= indexedQuery.end; j++) {
                        if (frequencies[j - 1] <= frequencies[j]) {
                            newSubArrayEnd += 1;
                        } else {
                            failures.insert({indexedQuery.start, pos});
                            break;
                        }
                    }
                    subArrays[pos] = newSubArrayEnd;
                    if (newSubArrayEnd == indexedQuery.end){
                        isValid = true;
                    }
                } else {
                    isValid = true;
                }
                break;
            }
        }

        if (!isValid) {
            int validEnd = indexedQuery.start;
            for (int pos = indexedQuery.start+1; pos <= indexedQuery.end; pos++) {
                if (frequencies[pos - 1] <= frequencies[pos]) {
                    validEnd += 1;
                } else {
                    failures.insert({indexedQuery.start, pos});
                    break;
                }
            }
            subArrays[indexedQuery.start] = validEnd;
            if (validEnd == indexedQuery.end) {
                isValid = true;
            }
        }

        if (isValid) {
            output[indexedQuery.index] = true;
        } else {
            failures.insert({indexedQuery.start, indexedQuery.end});
            output[indexedQuery.index] = false;
        }
    }
    for (auto && i : output){
        if (i) {
            cout << "YES\n";
        } else {
            cout << "NO\n";
        }
    }
};


int main(){
    solve();
    return EXIT_SUCCESS;
}