#include <bits/stdc++.h>
#include <atcoder/all>

using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

struct S
{
    long long value;
    int size;
};
using F = long long;

S op(S a, S b) { return {a.value + b.value, a.size + b.size}; }
S e() { return {0, 0}; }
S mapping(F f, S x) { return {x.value + f * x.size, x.size}; }
F composition(F f, F g) { return f + g; }
F id() { return 0; }

int main()
{
    int N, M;
    cin >> N >> M;

    atcoder::lazy_segtree<S, op, e, F, mapping, composition, id> seg1(M);
    atcoder::lazy_segtree<S, op, e, F, mapping, composition, id> seg2(M);
    rep(i, M)
    {
        seg1.set(i, S(0, 1));
        seg2.set(i, S(0, 1));
    }

    vector<long long> A(N);

    vector<int> pos(N);
    vector<array<long long, 2>> LR(N);

    rep(i, N)
    {
        cin >> A[i] >> LR[i][0] >> LR[i][1];
        LR[i][0]--;
        pos[i] = i;

        seg1.apply(LR[i][0], LR[i][1], 1);
        seg2.set(i, S(A[i], 1));
    }

    long long ans = 0;
    rep(i, N)
    {
        ans += (LR[i][1] - LR[i][0]) * A[i];
        ans -= seg2.prod(LR[i][0], LR[i][1]).value;
    }

    // cout << ans << endl;

    int Q;
    cin >> Q;
    rep(_, Q)
    {
        int X, Y, U, V;
        cin >> X >> Y >> U >> V;
        X--, Y--, U--;

        ans -= (LR[X][1] - LR[X][0]) * A[X];
        ans += seg1.get(pos[X]).value * A[X];

        // cout << "minus: " << (LR[X][1] - LR[X][0]) * A[X] << ", " << seg1.get(pos[X]).value * A[X] << endl;

        seg1.apply(LR[X][0], LR[X][1], -1);
        seg2.set(pos[X], S(0, 1));

        ans += seg2.prod(LR[X][0], LR[X][1]).value;

        pos[X] = Y;
        LR[X] = {U, V};

        ans -= seg2.prod(LR[X][0], LR[X][1]).value;

        seg1.apply(LR[X][0], LR[X][1], 1);
        seg2.set(pos[X], S(A[X], 1));

        ans += (LR[X][1] - LR[X][0]) * A[X];
        ans -= seg1.get(pos[X]).value * A[X];

        // cout << "plus: " << (LR[X][1] - LR[X][0]) * A[X] << ", " << seg1.get(pos[X]).value * A[X] << endl;

        cout << ans << endl;
    }

    return 0;
}