#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>

using namespace std;
using ll = long long;

const int K = 550;
const int N = 100010;

int ans_block[(N + K) / K][K][K];
int SPMIN[(N + K) / K][10][K], SPMAX[(100010 + K) / K][10][K];
int nxt[(N + K) / K][100010];

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, q; cin >> n >> q;
    vector<int> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    
    vector<int> pos(n + 1);
    for (int i = 0; i < n; i++) {
        pos[a[i]] = i;
    }
    vector<int> bl(n, -1);
    int ind= -1;
    for (int i = 0; i < n; i += K) {
        ind++;
        vector<int> ppos;
        for (int j = i + 1; j <= min(n, i + K); j++) {
            bl[pos[j]] = ind;
            ppos.push_back(pos[j]);
        }
        nxt[ind][n] = n + 1;
        int INDD = ppos.size() - 1;
        for (int j = n - 1; j >= 0; j--) {
            nxt[ind][j] = nxt[ind][j + 1];
            if (bl[j] == ind) nxt[ind][j] = INDD--;
        }
        for (int I = 0; I < ppos.size(); I++) {
            SPMIN[ind][0][I] = a[ppos[I]];
            SPMAX[ind][0][I] = a[ppos[I]];
        }
        for (int j = 1; j < 10; j++) {
            for (int I = 0; I + (1 << j) - 1 < ppos.size(); I++) {
                SPMIN[ind][j][I] = min(SPMIN[ind][j - 1][I], SPMIN[ind][j - 1][I + (1 << (j - 1))]);
                SPMAX[ind][j][I] = max(SPMAX[ind][j - 1][I], SPMAX[ind][j - 1][I + (1 << (j - 1))]);
            }
        }
        sort(ppos.begin(), ppos.end());
        vector<vector<int>> bd_right(ppos.size(), vector<int>(ppos.size())), bd_left(ppos.size(), vector<int>(ppos.size()));
        for (int I = 0; I < ppos.size() - 1; I++) {
            bd_right[I][I] = 1e9;
            bd_left[I][I] = 1e9;
            for (int j = I + 1; j < ppos.size(); j++) {
                bd_right[I][j] = bd_right[I][j - 1];
                bd_left[I][j] = bd_left[I][j - 1];
                if (a[ppos[j]] > a[ppos[I]] && bd_right[I][j] > a[ppos[j]] - a[ppos[I]]) {
                    bd_right[I][j] = a[ppos[j]] - a[ppos[I]];
                }
                if (a[ppos[j]] < a[ppos[I]] && bd_left[I][j] > a[ppos[I]] - a[ppos[j]]) {
                    bd_left[I][j] = a[ppos[I]] - a[ppos[j]];
                }
            }
        }
        vector<vector<int>> ans(ppos.size(), vector<int>(ppos.size()));
        for (int I = ppos.size() - 1; I >= 0; I--) {
            ans[I][I] = 0;
            ans_block[ind][I][I] = ans[I][I];
            for (int j = I - 1; j >= 0; j--) {
                ans[j][I] = ans[j + 1][I];
                int rg = (bd_right[j][I] == 1e9 ? -1 : a[ppos[j]] + bd_right[j][I]);
                int lf = (bd_left[j][I] == 1e9 ? -1 : a[ppos[j]] - bd_left[j][I]);
                if (rg != -1) ans[j][I] += abs(pos[rg] - pos[a[ppos[j]]]);
                if (lf != -1) ans[j][I] += abs(pos[lf] - pos[a[ppos[j]]]);
                if (lf != -1 && rg != -1) ans[j][I] -= abs(pos[lf] - pos[rg]);
                ans_block[ind][j][I] = ans[j][I];
            }
        }
    }
    vector<vector<int>> qrs(q);
    for (int i = 0; i < q; i++) {
        int l, r; cin >> l >> r; l--; r--;
        qrs[i] = {l, r, i};
    }
    sort(qrs.begin(), qrs.end(), [&](vector<int> &x, vector<int> &y) {
        return x[1] < y[1];
    });
    vector<int> Log2(n + 1, 0);
    for (int i = 2; i <= n; i++) Log2[i] = Log2[i / 2] + 1; 
    auto getmax = [&](int block, int l, int r) {
        int lg = Log2[r - l + 1];
        return max(SPMAX[block][lg][l], SPMAX[block][lg][r - (1 << lg) + 1]);
    };
    auto getmin = [&](int block, int l, int r) {
        int lg = Log2[r - l + 1];
        return min(SPMIN[block][lg][l], SPMIN[block][lg][r - (1 << lg) + 1]);
    };
    int IND = 0;

    ind++;
    vector<int> last(ind, -1);
    vector<ll> ANSW(q);
    vector<int> cnt(ind);
    for (int r = 0; r < n; r++) {
        last[bl[r]] = cnt[bl[r]]++;
        while (IND < qrs.size() && qrs[IND][1] == r) {
            int L = qrs[IND][0], R = qrs[IND][1];
            ll ANS = 0;
            for (int j = 0; j < ind; j++) {
                if (nxt[j][L] <= last[j] && last[j] != -1) {
                    ANS += ans_block[j][nxt[j][L]][last[j]];
                }
            }
            int LAST = -1;
            for (int j = 0; j < ind; j++) {
                if (nxt[j][L] <= last[j] && last[j] > -1) {
                    int RG = getmax(j, nxt[j][L], last[j]), LF = getmin(j, nxt[j][L], last[j]);
                    if (LAST != -1) ANS += abs(pos[LF] - pos[LAST]);
                    LAST = RG;
                }
            }
            ANSW[qrs[IND][2]] = ANS;
            IND++;
        }
    }
    for (auto &u : ANSW) cout << u << '\n';
    return 0;
}