#include<bits/stdc++.h>
using namespace std;
#define ll long long
struct segTree{
    ll size;
    vector<ll>tree , lazy;
    void init(ll n){
        tree.clear();
        size =1;
        while(size < n){
            size*=2;
        }
        tree.assign(2*size ,0);
        lazy.assign(2*size ,0);
    }

    void update(ll x , ll lx , ll rx , ll q_lx , ll q_rx){
        if(q_lx<=lx && q_rx>=rx){
            lazy[x]++;
            return;
        }
        if(q_lx > rx || q_rx < lx) return;

        lazy[2*x+1] += lazy[x];
        lazy[2*x] += lazy[x];
        lazy[x] = 0;

        ll mid = (lx+rx)>>1;
        update(2*x , lx , mid , q_lx , q_rx);
        update(2*x+1 , mid+1 , rx , q_lx , q_rx);
    }

    void update(ll q_lx , ll q_rx){
        update(1 , 0, size-1 , q_lx , q_rx);
    }

    ll query(ll x ,ll lx ,ll rx , ll ind){
        if(lx==rx){
            tree[x] += lazy[x];
            lazy[x] = 0;
            return tree[x];
        }

        lazy[2*x+1] += lazy[x];
        lazy[2*x] += lazy[x];
        lazy[x] = 0;

        ll mid = (lx+rx)>>1;
        if(ind<=mid && ind >= lx){
            return query(2*x , lx , mid , ind);
        }
        else{
            return query(2*x+1 , mid+1 , rx , ind);
        }
    }

    ll query(ll i){
        return query(1 ,0 , size-1, i);
    }

}st;


vector<ll> Solve(vector<vector<ll>>&A, vector<vector<ll>>&B) {
    ll total_monster =0;
    vector<ll>Power;
    for(int i=0;i<A.size();i++){
        swap(A[i][2] , A[i][0]);
        swap(A[i][2] , A[i][1]);
    }

    sort(A.begin() , A.end());
    for(auto it : A){
        Power.push_back(it[0]);
    }

    //Given ranges we have to find number of time B[i][0] occur in [o...i]
    //we can make segtree and point query can be done
    st.init(100000+7);
    map<ll, vector<ll>>LST_LIMIT;
    for(int i=0;i<B.size();i++){
        auto it = lower_bound(Power.begin() , Power.end() , B[i][1]);
        if(it!=Power.begin()) LST_LIMIT[(it-Power.begin()) - 1].push_back(i);
    }

    vector<ll>Ans(B.size() , 0);
    for(int i=0;i<A.size();i++){
        ll l = A[i][1];
        ll r = A[i][2];
        total_monster += (r-l+1);
        st.update(l ,r);

        if(LST_LIMIT.count(i)){
            //update answer for those
            for(auto x : LST_LIMIT[i]){
                //we want number of elements that are present at its position
                Ans[x] = st.query(B[x][0]);
            }
        }
    }
    //Now we have our answer

    unordered_map<ll ,ll>pre_Ans;
    vector<ll>Finals(B.size());

    ll prev_ans = total_monster;
    for(int i=0;i<B.size();i++){
        if(pre_Ans.count(B[i][0])){
            //the hero that deletes some at this position is let x
            ll x = pre_Ans[B[i][0]];
            if(B[x][1] < B[i][1]){
                //remove old ans and add new
                prev_ans += Ans[x];
                prev_ans -= Ans[i];
                pre_Ans[B[i][0]]= i;
                Finals[i] = prev_ans;
            }
            else{
                Finals[i] = prev_ans;
            }
        }
        else{
            pre_Ans[B[i][0]] = i;
            prev_ans -= Ans[i];
            Finals[i] = prev_ans;
        }
    }
    return Finals;
}

int main(){
    vector<vector<ll>>A = {{2 ,5 ,8} , {5 ,8 ,6} , {3 , 6 ,9} , {7 ,10, 10}};
    vector<vector<ll>>B = {{2 ,7} , {7 ,9} , {7 ,11}};

    vector<ll>Ans = Solve(A , B);
    for(auto it :Ans){
        cout<<it<<" ";
    }
    cout<<endl;

    return 0;
}