#include using namespace std; template class y_combinator { F f; public: y_combinator(F&& f) : f(std::forward(f)) {} template auto operator()(Args&&... args) const { return f(*this, std::forward(args)...); } }; using ll = long long; using ld = long double; using u8 = uint8_t; using u32 = uint32_t; using u64 = uint64_t; using vi = vector; using vl = vector; using pii = pair; using pll = pair; template > using prique = std::priority_queue, U>; inline constexpr int popcnt(u64 x) noexcept { return __builtin_popcountll(x); } template T floor(T a, T b) noexcept { return a / b - (a % b && (a ^ b) < 0); } template T ceil(T a, T b) noexcept { return floor(a + b - 1, b); } template bool chmin(T& x, const T& y) noexcept { return (x > y ? x = y, true : false); } template bool chmax(T& x, const T& y) noexcept { return (x < y ? x = y, true : false); } template void dedup(std::vector& v) { std::sort(std::begin(v), std::end(v)), v.erase(std::unique(std::begin(v), std::end(v)), std::end(v)); } template ll bisect(ll ok, ll ng, const F& f) { while (abs(ok - ng) > 1) { ll mid = (ok + ng) / 2; (f(mid) ? ok : ng) = mid; } return ok; } template ld bisect_real(ld ok, ld ng, const F& f, int iter = 80) { while (iter--) { ld mid = (ok + ng) / 2.; (f(mid) ? ok : ng) = mid; } return ok; } void SCAN() {} template void SCAN(H& h, T&... t) { std::cin >> h, SCAN(t...); } #define INT(...) int __VA_ARGS__; SCAN(__VA_ARGS__) #define LL(...) long long __VA_ARGS__; SCAN(__VA_ARGS__) #define LD(...) long double __VA_ARGS__; SCAN(__VA_ARGS__) #define STR(...) std::string __VA_ARGS__; SCAN(__VA_ARGS__) #define CHAR(...) char __VA_ARGS__; SCAN(__VA_ARGS__) #define VEC(type, name, size) std::vector name(size); for (int i = 0; i < (int)size; i++) SCAN(name[i]); #define VV(type, name, h, w) std::vector> name(h, std::vector(w)); for (int i = 0; i < (int)h; i++) for (int j = 0; j < (int)w; j++) SCAN(name[i][j]); #define overload4(a, b, c, d, e, ...) e #define rep1(a) for (long long _i = 0; _i < (a); _i++) #define rep2(i, a) for (long long i = 0; i < (a); i++) #define rep3(i, a, b) for (long long i = (a); i < (b); i++) #define rep4(i, a, b, c) for (long long i = (a); i < (b); i += (c)) #define rep(...) overload4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__) #define rrep(i, a, b, c) for (long long i = (a); i > (b); i += (c)) #define all(x) std::begin(x), std::end(x) #define rall(x) std::rbegin(x), std::rend(x) #define len(x) (long long)(size(x)) #define pb push_back #ifndef LOCAL #define debug(...) #endif #include using mint = atcoder::modint998244353; #include struct S { ll value; ll size; }; using F = ll; 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 + x.size * f, x.size}; } F composition(F f, F g) { return f + g; } F id() { return 0; } void run_case() { LL(N, M); vl A(N), L(N), R(N), P(N); rep(i, N) cin >> A[i] >> L[i] >> R[i], L[i]--, P[i] = i; vector init(M, {0, 1}); rep(i, N) init[i] = {A[i], 1}; vector isis(M, {0, 1}); atcoder::lazy_segtree sumb(init), count(isis); ll ans = 0; rep(i, N) { count.apply(L[i], R[i], 1); ans += A[i] * (R[i] - L[i]); ll t = sumb.prod(L[i], R[i]).value; ans -= t; } debug(ans); INT(Q); rep(Q) { LL(x, y, u, v); x--, y--; u--; ll t = 0; t -= A[x] * (R[x] - L[x]); t += sumb.prod(L[x], R[x]).value; count.apply(L[x], R[x], -1); t += count.get(P[x]).value * A[x]; int py = P[x]; sumb.apply(py, -A[x]); P[x] = y; L[x] = u, R[x] = v; sumb.apply(y, A[x]); t += A[x] * (R[x] - L[x]); t -= sumb.prod(L[x], R[x]).value; t -= count.get(P[x]).value * A[x]; count.apply(L[x], R[x], 1); ans += t; cout << ans << "\n"; } } int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); std::fixed(std::cout).precision(16); int T = 1; while (T--) run_case(); return 0; }