#include <bits/stdc++.h>
using namespace std;
//
const int mx = 100000;
const int S = 30;
//
int n, q, A[mx], B[mx];
long long ans[mx];
tuple<int, int, int, int> query[mx];
vector<tuple<int, int, bool>> P[mx / S + 5];
//
namespace Fenwick_Tree
{
    pair<int, long long> bit[mx + 5];
    //
    void update (int idx, int val, bool inc)
    {
        for (; idx <= n; idx += idx & -idx)
            bit[idx].first += inc ? 1 : -1,
            bit[idx].second += inc ? val : -val;
    }
    pair<int, long long> get (int l, int r)
    {
        pair<int, long long> res(0, 0);
        //
        if (l > r)
            return res;
        --l;
        for (int idx = l; idx > 0; idx -= idx & -idx)
            res.first -= bit[idx].first,
            res.second -= bit[idx].second;
        for (int idx = r; idx > 0; idx -= idx & -idx)
            res.first += bit[idx].first,
            res.second += bit[idx].second;
        return res;
    }
}
//
long long calc (int a, int b, int c, int d)
{
    long long res = 0;
    pair<int, long long> p1, p2;
    //
    if (a == b || c == d)
        return 0;
    for (int i = a; i < b; ++i)
        Fenwick_Tree::update(B[i], A[i], 1);
    for (int i = c; i < d; ++i)
    {
        p1 = Fenwick_Tree::get(1, B[i] - 1);
        p2 = Fenwick_Tree::get(B[i] + 1, n);
        res += (1LL * p1.first * A[i] - p1.second) + (p2.second - 1LL * p2.first * A[i]);
    }
    for (int i = a; i < b; ++i)
        Fenwick_Tree::update(B[i], A[i], 0);
    return res;
}
void prepare (void)
{
    vector<int> V(A, A + n);
    //
    auto func = [&](int idx, bool inc, int x, int y) -> void
    {
        int u = x / S * S, v = y / S * S;
        //
        if (u == 0)
            if (v == 0)
                ans[idx] += inc ? calc(0, x, 0, y) : -calc(0, x, 0, y);
            else
                P[v / S].emplace_back(x, idx, inc),
                ans[idx] += inc ? calc(0, x, v, y) : -calc(0, x, v, y);
        else
            if (v == 0)
                P[u / S].emplace_back(y, idx, inc),
                ans[idx] += inc ? calc(u, x, 0, y) : -calc(u, x, 0, y);
            else
                P[u / S].emplace_back(y, idx, inc),
                P[v / S].emplace_back(x, idx, inc),
                P[v / S].emplace_back(u, idx, inc ^ 1),
                ans[idx] += inc ? calc(u, x, v, y) : -calc(u, x, v, y);
    };
    //
    sort(V.begin(), V.end());
    V.erase(unique(V.begin(), V.end()), V.end());
    for (int i = 0; i < n; ++i)
        B[i] = upper_bound(V.begin(), V.end(), A[i]) - V.begin();

    for (int i = 0; i < n; ++i)
    {
        int a, b, c, d;
        //
        tie(a, b, c, d) = query[i];
        func(i, 1, b, d);
        if (a > 0)
            func(i, 0, a, d);
        if (c > 0)
            func(i, 0, b, c);
        if (a > 0 && c > 0)
            func(i, 1, a, c);
    }
}
void calculate (void)
{
    vector<int32_t> cnt(n + 5);
    vector<int64_t> sum(n + 5);
    //
    auto get = []<typename T>(vector<T> &V, int l, int r) -> long long
    {
        return V[r] - V[l - 1];
    };
    //
    for (int k = 1; k <= n / S; ++k)
    {
        fill(cnt.begin(), cnt.end(), 0);
        fill(sum.begin(), sum.end(), 0);
        for (int i = 0; i < min(n, k * S); ++i)
            cnt[B[i]]++,
            sum[B[i]] += A[i];
        for (int i = 1; i <= n; ++i)
            cnt[i] += cnt[i - 1],
            sum[i] += sum[i - 1];
        //
        int i = -1;
        long long res = 0;
        //
        sort(P[k].begin(), P[k].end());
        for (auto [d, idx, inc] : P[k])
        {
            while (i + 1 < d)
            {
                ++i;
                res += (get(cnt, 1, B[i] - 1) * A[i] - get(sum, 1, B[i] - 1))
                     + (get(sum, B[i] + 1, n) - get(cnt, B[i] + 1, n) * A[i]);
            }
            ans[idx] += inc ? res : -res;
        }
    }
}
//
void process (void)
{
    cin >> n >> q;
    for (int i = 0; i < n; ++i)
        cin >> A[i];
    for (int i = 0; i < q; ++i)
    {
        int a, b, c, d;
        //
        cin >> a >> b >> c >> d;
        query[i] = make_tuple(--a, b, --c, d);
    }

    prepare();
    calculate();

    for (int i = 0; i < q; ++i)
        cout << ans[i] << '\n';
}
//
signed main (void)
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    process();
}