// #pragma GCC target("avx2")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")


#include<bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
template<class T> using VVV = V<VV<T>>;
template<class T> using VVVV = VV<VV<T>>;
#define rep(i,n) for(ll i=0ll;(i)<(n);(i)++)
#define REP(i,a,n) for(ll i=(a);(i)<(n);(i)++)
#define rrep(i,n) for(ll i=(n)-1;(i)>=(0ll);(i)--)
#define RREP(i,a,n) for(ll i=(n)-1;(i)>=(a);(i)--)
const long long INF = (1LL << 60);
const long long mod99 = 998244353;
const long long mod107 = 1000000007;
const long long mod = mod99;
#define eb emplace_back
#define be(v) (v).begin(),(v).end()
#define all(v) (v).begin(),(v).end()
#define foa(i,v) for(auto& (i) : (v))
#define UQ(v) sort(be(v)), (v).erase(unique(be(v)), (v).end())
#define UQ2(v,cmp) sort(be(v)), (v).erase(unique(be(v),cmp), (v).end())
#define UQ3(v,cmp) sort(be(v),cmp), (v).erase(unique(be(v)), (v).end())
#define UQ4(v,cmp,cmp2) sort(be(v), cmp), (v).erase(unique(be(v),cmp2), (v).end())
#define LB(x,v) (lower_bound(be(v),(x))-(v).begin())
#define LB2(x,v,cmp) (lower_bound(be(v),(x),(cmp))-(v).begin())
#define UB(x,v) (upper_bound(be(v),(x))-(v).begin())
#define UB2(x,v,cmp) (upper_bound(be(v),(x),(cmp))-(v).begin())
#define dout()  cout << fixed << setprecision(20)
#define randinit() srand((unsigned)time(NULL))

template<class T, class U> bool chmin(T& t, const U& u) { if (t > u){ t = u; return 1;} return 0; }
template<class T, class U> bool chmax(T& t, const U& u) { if (t < u){ t = u; return 1;} return 0; }


ll Rnd(ll L=0, ll R=mod99){return rand()%(R-L)+L;}

template <typename T, T (*OP)(T, T), T (*E)()>
struct segtree { 
    vector<T> seg;
    int seg_size, _n;//葉の数
    
    segtree(int N) : seg(), seg_size(), _n(N) {
        seg_size = 1;
        while(seg_size < N) seg_size <<= 1;
        seg.resize(seg_size<<1, E());
    }
    segtree(const vector<T> a) : seg(), seg_size(), _n(a.size()) {
        int N = a.size();
        seg_size = 1;
        while(seg_size < N) seg_size <<= 1;
        seg.resize(seg_size<<1, E());
        for(int i=0; i<N; i++) seg[i + seg_size] = a[i];
        for(int i = seg_size-1; i > 0; i --){
            seg[i] = OP(seg[(i<<1)], seg[(i<<1)|1]);
        }
    }
    
    void set(int idx, T x){
        idx += seg_size;
        seg[idx] = x;
        update(idx);
    }
    T get(int idx){
        idx += seg_size;
        return seg[idx];
    }
    
    void apply(int idx, T x){
        idx += seg_size;
        seg[idx] = OP(seg[idx], x);
        update(idx);
    }

    void update(int idx){
        while(idx > 1){
            idx >>= 1;
            seg[idx] = OP(seg[idx<<1], seg[(idx<<1)|1]);
        }
    }
    
    
    T prod(int left, int right) {
        if(left < 0) left = 0;
        if(right > _n) right = _n;
        if(left > right) return E();

        left += seg_size;
        right += seg_size;

        T retl= E(), retr = E();
        {
            int L = left, R = right;
            while(L < R){
                if(L&1){
                    retl = OP(retl, seg[L]);
                    L++;
                }
                if(R&1){
                    R--;
                    retr = OP(seg[R], retr);
                }
                L >>= 1;
                R >>= 1;
            }
        }
        return OP(retl, retr);
    }
    T all_prod(){ return seg[1]; }

    template<class F>
    int max_right(int left, F f) {
        if(left >= _n) return _n;
        if(left < 0) left = 0;
        T s = E();
        left += seg_size;
        do{
            while(left % 2 == 0) left >>= 1;
            if(!f(OP(s, seg[left]))){
                while(left < seg_size){
                    left <<= 1;
                    if(f(OP(s, seg[left]))){
                        s = OP(s, seg[left]);
                        left++;
                    }
                }
                return left - seg_size;
            }
            s = OP(s, seg[left]);
            left++;
        }while((left & (left-1)));
        return _n;
    };

    template<class F>
    int min_left(int right, F f) {
        if(right <= 0) return 0;
        if(right >= _n) right = _n;
        T s = E();
        right += seg_size;
        do{
            while(right % 2 == 0) right >>= 1;
            if(right != 1) right --;
            if(!f(OP(seg[right], s))){
                while(right < seg_size){
                    right <<= 1;
                    right |= 1;
                    if(f(OP(seg[right], s))){
                        s = OP(seg[right], s);
                        right ^= 1;
                    }
                }
                return right - seg_size;
            }
            s = OP(seg[right], s);
        }while((right & (right-1)));
        return 0;
    };
};

/*
ll e(){return -INF;}
ll op(ll L, ll R){return max(L, R);}
*/


ll op(ll l, ll r){return l+r;}
ll e(){return 0;}

void solve(){
    ll n,m;
    cin >> n >> m;
    m++;
    segtree<ll, op, e> seg1(m), seg2(m);
    ll ans = 0;
    V<ll> A(n+1), L(n+1), R(n+1), P(n+1);
    rep(i,n){
    	ll a,l,r;
    	cin >> a >> l >> r;
    	l--;
    	ans -= seg2.prod(0, i+1) * a;
    	seg2.apply(l, 1);
    	seg2.apply(r, -1);
    	
    	seg1.apply(i+1, a);
    	ans -= seg1.prod(l+1, r+1);
    	ans += a * (r-l);
    	A[i+1] = a;
    	L[i+1] = l;
    	R[i+1] = r;
    	P[i+1] = i+1;
    }
    
    ll q;
    cin >> q;
    while(q--){
    	ll x,y,u,v;
    	cin >> x >> y >> u >> v;
    	u--;
 
    	ans -= A[x] * (R[x] - L[x]);
    	ans += seg2.prod(0, P[x]) * A[x];
    	seg1.apply(P[x], -A[x]);
    	seg2.apply(L[x], -1);
    	seg2.apply(R[x], 1);
    	ans += seg1.prod(L[x]+1, R[x]+1);
    	
    	P[x] = y;
    	L[x] = u;
    	R[x] = v;
    	
    	ans -= seg1.prod(L[x]+1, R[x]+1);
    	seg1.apply(P[x], A[x]);
    	seg2.apply(L[x], 1);
    	seg2.apply(R[x], -1);
    	ans += A[x] * (R[x] - L[x]);
    	ans -= seg2.prod(0, P[x]) * A[x];
    	
    	cout << ans << '\n';
    }
}

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int t=1;
    // cin >> t;
    rep(i,t) solve();
}