#include <bits/stdc++.h>
using namespace std;

struct Mo{
    int n;
    vector<pair<int, int>> lr;

    Mo(const int n) : n(n) {}

    /* [l, r) */
    void add(const int l, const int r){
        lr.emplace_back(l, r);
    }

    template <typename AL, typename AR, typename EL, typename ER, typename O>
    void build(const AL &add_left, const AR &add_right, const EL &erase_left, const ER &erase_right, const O &out){
        int q = (int) lr.size();
        int border = max<int>(1, 1.0 * n / max<double>(1.0, sqrt(q * 2.0 / 3.0)));
        vector<int> ord(q);
        iota(ord.begin(), ord.end(), 0);
        sort(ord.begin(), ord.end(), [&](int a, int b){
            int ablock = lr[a].first / border, bblock = lr[b].first / border;
            if(ablock != bblock){
                return ablock < bblock;
            }
            return (ablock & 1) ? lr[a].second > lr[b].second : lr[a].second < lr[b].second;
        });
        int l = 0, r = 0;
        for(const auto &k : ord){
            while(l > lr[k].first) add_left(--l);
            while(r < lr[k].second) add_right(r++);
            while(l < lr[k].first) erase_left(l++);
            while(r > lr[k].second) erase_right(--r);
            out(k);
        }
    }

    template <typename A, typename E, typename O>
    void build(const A &add, const E &erase, const O &out){
        build(add, add, erase, erase, out);
    }
};

template <typename T>
struct BinaryIndexedTree{
    int N;
    std::vector<T> BIT;
    BinaryIndexedTree(const int N) : N(N), BIT(N + 1, 0){
    }

    T get(int i){
        return sum(i + 1) - sum(i);
    }

    void add(int i, T x){
        i++;
        while(i <= N){
            BIT[i] += x;
            i += i & -i;
        }
    }

    T sum(int i) const {
        T ans = 0;
        while(i > 0){
            ans += BIT[i];
            i -= i & -i;
        }
        return ans;
    }

    T sum(int L, int R) const {
        return sum(R) - sum(L);
    }

    int lower_bound(T x) const {
        if(x <= 0){
            return 0;
        } else{
            int v = 0, r = 1;
            while(r < N) r = r << 1;
            for(int len = r; len > 0; len = len >> 1){
                if(v + len < N && BIT[v + len] < x){
                    x -= BIT[v + len];
                    v += len;
                }
            }
            return v;
        }
    }

    int upper_bound(T x) const {
        if(x < 0){
            return 0;
        } else{
            int v = 0, r = 1;
            while(r <= N) r = r << 1;
            for(int len = r; len > 0; len = len >> 1){
                if(v + len <= N && BIT[v + len] <= x){
                    x -= BIT[v + len];
                    v += len;
                }
            }
            return v;
        }
    }

    T operator [](int i) const {
        return sum(i, i + 1);
    }
};

const int MAX_A = 100000;

int main(){
    int N, Q; cin >> N >> Q;
    vector<long long> A(N), B(N);
    for(int i = 0; i < N; i++){
        cin >> A[i];
    }
    for(int i = 0; i < N; i++){
        cin >> B[i];
    }

    Mo mo(N);
    for(int i = 0; i < Q; i++){
        int l, d, r, u; cin >> l >> d >> r >> u;
        l--; d--;
        mo.add(l, d);
        mo.add(l, u);
        mo.add(r, d);
        mo.add(r, u);
    }
    
    BinaryIndexedTree<long long> cntA(MAX_A + 1), valA(MAX_A + 1), cntB(MAX_A + 1), valB(MAX_A + 1);
    vector<long long> res(Q * 4);

    long long cur = 0;
    auto erase_left = [&](int i){
        cur += cntB.sum(0, A[i]) * A[i];
        cur += valB.sum(A[i], MAX_A + 1);
        cntA.add(A[i], 1);
        valA.add(A[i], A[i]);
    };
    auto add_right = [&](int i){
        cur += cntA.sum(0, B[i]) * B[i];
        cur += valA.sum(B[i], MAX_A + 1);
        cntB.add(B[i], 1);
        valB.add(B[i], B[i]);
    };
    auto add_left = [&](int i){
        cur -= cntB.sum(0, A[i]) * A[i];
        cur -= valB.sum(A[i], MAX_A + 1);

        cntA.add(A[i], -1);
        valA.add(A[i], -A[i]);
    };
    auto erase_right = [&](int i){
        cur -= cntA.sum(0, B[i]) * B[i];
        cur -= valA.sum(B[i], MAX_A + 1);
        cntB.add(B[i], -1);
        valB.add(B[i], -B[i]);
    };
    auto output = [&](int q){
        res[q] = cur;
    };
    mo.build(add_left, add_right, erase_left, erase_right, output);

    for(int i = 0; i < Q; i++){
        long long ans = res[i * 4] - res[i * 4 + 1] - res[i * 4 + 2] + res[i * 4 + 3];
        cout << ans << '\n';
    }
}