#include <vector>
#pragma GCC target ("avx2")
#pragma GCC optimize ("O3")
#pragma GCC optimize ("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>

using namespace std;
using namespace __gnu_pbds;

template<typename T>
ostream_iterator<T> oit(const string &s = " "){ return ostream_iterator<T>(cout,s.c_str()); }
inline auto rep(int l, int r) { return views::iota(min(l, r), r); }
inline auto rep(int n) { return rep(0, n); }
inline auto rep1(int l, int r) { return rep(l, r + 1); }
inline auto rep1(int n) { return rep(1, n + 1); }
inline auto per(int l, int r) { return rep(l, r) | views::reverse; }
inline auto per(int n) { return per(0, n); }
inline auto per1(int l, int r) { return per(l, r + 1); }
inline auto per1(int n) { return per(1, n + 1); }
#define A(a) begin(a),end(a)
inline auto len = ranges::ssize;

struct chash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
template<typename T, typename U> using pb_map = gp_hash_table<T, U, chash>;
template<typename T> using pb_set = gp_hash_table<T, null_type, chash>;
#define K first
#define V second

using ll = long long;
using ld = long double;

using vi = vector<int>;
using vii = vector<vector<int>>;
typedef vector<ll> vll;
using pll = pair<ll,ll>;
using pii = pair<int,int>;

constexpr ll NN = 1<<19, M = 1000000007, L = 20;

struct Node{
    ll p_len,s_len,front,back,len,ans;
};

namespace seg {
    using T = Node;
    T id={-1};
    T f(T a, T b) {
        if(a.p_len==-1) return b;
        if(b.p_len==-1) return a;

        Node res {a.p_len,b.s_len,a.front,b.back,a.len+b.len,a.ans+b.ans};
        if(a.back > b.front) return res; //trivial result
        else{ //the answer has changed
            res.ans += a.s_len*b.p_len;
        }
        if(a.p_len == a.len) res.p_len += b.p_len;
        if(b.s_len == b.len) res.s_len += a.s_len;

        return res;
    }

    T t[2 * NN];
    ll n=NN;  // array size

    void modify(ll p, T value) {  // set value at position p
      for (p+=n, t[p] = value; p /= 2;) t[p] = f(t[2*p], t[2*p+1]);
    }

    T query(ll l, ll r) { // fold f on interval [l, r)
      T resl=id, resr=id;
      for (l += n, r += n; l < r; l /= 2, r /= 2) {
        if (l&1) resl = f(resl, t[l++]);
        if (r&1) resr = f(t[--r], resr);
      }
      return f(resl, resr);
    }


}

void run()
{
    ll n,q; cin >> n >> q;
    vll a(n); for(ll &x : a) cin >> x;
    vll dp_l(n);
    dp_l[0]=0;
    for(int i : rep(1,n))
        dp_l[i] = (a[i]>=a[i-1] ? dp_l[i-1] : i);
    vll dp_r(n);
    dp_r[n-1]=n-1;
    for(int i : per(n-1))
        dp_r[i] = (a[i]<=a[i+1] ? dp_r[i+1] : i);

    vll p(n);
    for(ll i : rep(n)){
        if(dp_r[i]==i){
            ll ln = i-dp_l[i]+1;
            p[i] += ln*(ln-1)/2 + ln;
        }
        if(i) p[i]+=p[i-1];
    }

    auto query = [&](int l,int r){
        ll ans = 0;
        if(dp_l[r] <= l){
            ll ln = r-l+1;
            return ln*(ln-1)/2 + ln;
        }
        if(r != dp_r[r]){
            ll ln = r-dp_l[r]+1;
            ans += ln*(ln-1)/2 + ln;
            r = dp_l[r]-1;
        }
        if(l != dp_l[l]){
            // cout << "HERE\n";
            ll ln = dp_r[l]-l+1;
            ans += ln*(ln-1)/2 + ln;
            l = dp_r[l]+1;
        }
        if(l>r) return ans;

        ans += p[r]-(l ? p[l-1] : 0);

        return ans;
    };

    // for(int i : rep(n))
    //     seg::modify(i,{1,1,a[i],a[i],1,1});
    // for(int i : rep(n)){
    //     for(int j : rep(i,n)){
    //         assert(query(i,j)==seg::query(i,j+1).ans);
    //     }
    // }
    

    while(q--){
        int l,r; cin >> l >> r,--l,--r;

        auto rng = rep1(l,r);
        int idx = *ranges::partition_point(rng,[&](ll i){
            // auto s1 = seg::query(l,i+1);
            // auto s2 = seg::query(i,r+1);
            // return s1.ans < s2.ans;
            ll s1 = query(l,i);
            ll s2 = query(i,r);
            return s1 < s2;
        }); 
        
        ll here = query(l,idx);
        
        if(idx>l){
            --idx;
            here = min(here,query(idx,r));
        }
        cout << here << '\n';
    }
}

int main()
{
    //KING OF THE WORLD...... U.W.T.B
    cin.tie(0);
    run();
}