#include <algorithm>
#include <iostream>
#include <numeric>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#include <limits>

#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
using namespace std;
using ll = long long int;  // NOLINT
using P = pair<ll, ll>;

// clang-format off
#ifdef _DEBUG_
#define dump(...) do{ cerr << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; debug_print(__VA_ARGS__); } while(false)
template<typename T, typename... Ts> void debug_print(const T &t, const Ts &...ts) { cerr << t; ((cerr << ", " << ts), ...); cerr << endl; }
#else
#define dump(...) do{ } while(false)
#endif
template<typename T> vector<T> make_v(size_t a, T b) { return vector<T>(a, b); }
template<typename... Ts> auto make_v(size_t a, Ts... ts) { return vector<decltype(make_v(ts...))>(a, make_v(ts...)); }
template<typename T> bool chmin(T &a, const T& b) { if (a > b) {a = b; return true; } return false; }
template<typename T> bool chmax(T &a, const T& b) { if (a < b) {a = b; return true; } return false; }
template<typename T, typename... Ts> void print(const T& t, const Ts&... ts) { cout << t; ((cout << ' ' << ts), ...); cout << '\n'; }
constexpr static struct PositiveInfinity { template<typename T> constexpr operator T() const { return numeric_limits<T>::max() / 2; } constexpr auto operator-() const; } inf;  // NOLINT
constexpr static struct NegativeInfinity { template<typename T> constexpr operator T() const { return numeric_limits<T>::lowest() / 2; } constexpr auto operator-() const; } NegativeInfinityVal;
constexpr auto PositiveInfinity::operator-() const { return NegativeInfinityVal; }
constexpr auto NegativeInfinity::operator-() const { return inf; }
// clang-format on

#include <algorithm>
#include <tuple>
#include <vector>
#include <type_traits>
template<typename T, typename E>
void compress_insert(std::vector<T> &inserter, const std::vector<E> &v) {
    inserter.insert(inserter.end(), v.begin(), v.end());
}
template<typename T, typename E>
std::vector<int> compress_update(std::vector<T> &inserter, const std::vector<E> &v) {
    std::vector<int> ret(v.size());
    std::transform(v.begin(), v.end(), ret.begin(), [&](const E &e) { return static_cast<int>(std::lower_bound(inserter.begin(), inserter.end(), e) - inserter.begin()); });
    return ret;
}
template<typename... Args>
auto compress(const Args &...args) {
    std::vector<std::common_type_t<typename Args::value_type...>> inserter;
    (..., compress_insert(inserter, args));
    sort(inserter.begin(), inserter.end());
    inserter.erase(unique(inserter.begin(), inserter.end()), inserter.end());
    return std::tuple_cat(std::make_tuple(inserter), std::make_tuple(compress_update(inserter, args)...));
}

#include <vector>
#include <bit>
namespace STF {
    template<typename T>
    [[maybe_unused]] constexpr static auto Sum = [](const T &a, const T &b) -> T { return a + b; };
    template<typename T>
    [[maybe_unused]] constexpr static auto Update = []([[maybe_unused]] const T &a, const T &b) -> T { return b; };
    template<typename T>
    [[maybe_unused]] constexpr static auto Min = [](const T &a, const T &b) -> T { return min(a, b); };
    template<typename T>
    [[maybe_unused]] constexpr static auto Max = [](const T &a, const T &b) -> T { return max(a, b); };
}  // namespace STF
template<typename T, typename UpdateFunction, typename QueryFunction>
class SegmentTree {
    std::vector<T> data;
    int n;
    UpdateFunction update_func;
    QueryFunction query_func;

public:
    SegmentTree(const std::vector<T> &v, const T &init, const UpdateFunction &uf, const QueryFunction &qf) : update_func(uf), query_func(qf) {
        n = static_cast<int>(v.size());
        int size = static_cast<int>(std::bit_ceil(v.size()));
        data.resize(2 * size, init);
        for (int i = 0; i < n; i++) {
            data[size + i] = v[i];
        }
        for (int i = size - 1; i >= 1; i--) {
            data[i] = query_func(data[2 * i], data[2 * i + 1]);
        }
    }
    SegmentTree(const int nv, const T &init, const UpdateFunction &uf, const QueryFunction &qf) : SegmentTree(std::vector<T>(nv, init), init, uf, qf) {}
    // 0-indexed
    void update(int pos, const T &val) {
        if (pos < 0 || pos >= n)
            return;
        pos += static_cast<int>(data.size()) / 2;
        data[pos] = update_func(data[pos], val);
        while (pos > 1) {
            pos >>= 1;
            data[pos] = query_func(data[2 * pos], data[2 * pos + 1]);
        }
    }
    // [l, r), 0-indexed
    T query(int l, int r) const {
        const T &init = data.front();
        if (l < 0 || r > n)
            return init;
        T res_l = init, res_r = init;
        int size = static_cast<int>(data.size()) / 2;
        for (l += size, r += size; l < r; l >>= 1, r >>= 1) {
            if (l & 1) {
                res_l = query_func(res_l, data[l++]);
            }
            if (r & 1) {
                res_r = query_func(data[--r], res_r);
            }
        }
        return query_func(res_l, res_r);
    }
};
template<typename T, typename UpdateFunction, typename QueryFunction>
SegmentTree(const std::vector<T> &, const T &, const UpdateFunction &, const QueryFunction &) -> SegmentTree<T, UpdateFunction, QueryFunction>;
template<typename T, typename UpdateFunction, typename QueryFunction>
SegmentTree(const int, const T &, const UpdateFunction &, const QueryFunction &) -> SegmentTree<T, UpdateFunction, QueryFunction>;

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n, q;
    cin >> n >> q;
    vector<int> a(n);
    rep(i, 0, n) {
        cin >> a[i];
    }
    a = get<1>(compress(a));
    vector<int> cnt(a.size(), 0);
    rep(i, 0, a.size()) {
        cnt[a[i]]++;
    }
    SegmentTree seg(cnt, 0, STF::Update<int>, STF::Sum<int>);
    rep(i, 0, q) {
        int x, y;
        cin >> x >> y;
        x = a[x - 1];
        y = a[y - 1];
        dump(x, y);
        if (x <= y) {
            print(0);
        } else {
            print(seg.query(y + 1, x));
        }
    }

    return 0;
}