#include <bits/stdc++.h>
#define N 200005
#define INF 1000000000000000001
#define ls(u) tr[u].ls
#define rs(u) tr[u].rs
using namespace std;
typedef long long ll;

struct SegT
{
    struct Seg { int ls, rs; ll mx, hmx, tg, htg; } tr[N*2];
    int rt, tot;

    void build (int &u, int l, int r)
    {
        if (!u) { u=++tot; }
        tr[u]=(Seg){ ls(u), rs(u), -INF, -INF, 0, 0 };
        if (l==r) { return; }
        int md=(l+r)>>1;
        build(ls(u), l, md);
        build(rs(u), md+1, r);
    }

    void pushdown (int u)
    {
        if (tr[u].tg==0 && tr[u].htg==0) { return; }
        tr[ls(u)].hmx=max(tr[ls(u)].hmx, tr[ls(u)].mx+tr[u].htg); tr[ls(u)].mx+=tr[u].tg;
        tr[ls(u)].htg=max(tr[ls(u)].htg, tr[ls(u)].tg+tr[u].htg); tr[ls(u)].tg+=tr[u].tg;
        tr[rs(u)].hmx=max(tr[rs(u)].hmx, tr[rs(u)].mx+tr[u].htg); tr[rs(u)].mx+=tr[u].tg;
        tr[rs(u)].htg=max(tr[rs(u)].htg, tr[rs(u)].tg+tr[u].htg); tr[rs(u)].tg+=tr[u].tg;
        tr[u].tg=0; tr[u].htg=0;
    }
    void pushup (int u)
    {
        tr[u].mx=max(tr[ls(u)].mx, tr[rs(u)].mx);
        tr[u].hmx=max(tr[ls(u)].hmx, tr[rs(u)].hmx);
    }

    void upd (int u, int l, int r, int id, ll num)
    {
        if (l==r) { tr[u].mx=num; tr[u].hmx=max(tr[u].hmx, num); return; }
        pushdown(u);
        int md=(l+r)>>1;
        if (id<=md) upd(ls(u), l, md, id, num);
        else upd(rs(u), md+1, r, id, num);
        pushup(u);
    }
    void add (int u, int l, int r, int ql, int qr, ll num)
    {
        if (l>qr || r<ql) { return; }
        if (ql<=l && r<=qr) {
            tr[u].mx+=num; tr[u].hmx=max(tr[u].hmx, tr[u].mx);
            tr[u].tg+=num; tr[u].htg=max(tr[u].htg, tr[u].tg);
            return;
        }
        pushdown(u);
        int md=(l+r)>>1;
        add(ls(u), l, md, ql, qr, num);
        add(rs(u), md+1, r, ql, qr, num);
        pushup(u);
    }
    ll qrymx (int u, int l, int r, int ql, int qr)
    {
        if (l>qr || r<ql) { return -INF; }
        if (ql<=l && r<=qr) { return tr[u].hmx; }
        pushdown(u);
        int md=(l+r)>>1;
        ll resl=qrymx(ls(u), l, md, ql, qr);
        ll resr=qrymx(rs(u), md+1, r, ql, qr);
        return max(resl, resr);
    }

} ST;

int n, Q;
ll ans[N];
vector <int> ins[N], del[N];
struct Qry { int l, id; };
vector <Qry> qq[N], qq2[N];
struct Pnt { int h, a, b; } p[N];

void sol ()
{
    for (int i=1; i<=n; i++) {
        int l=i+p[i].a, r=i+p[i].b;
        r=min(r, n); l=min(l, r+1);
        if (l<=r) { ins[l].push_back(i); del[r+1].push_back(i); }
    }

    ST.build(ST.rt, 1, n);
    for (int i=1; i<=n; i++) {
        for (int j=0; j<(int)ins[i].size(); j++) {
            ST.upd(ST.rt, 1, n, ins[i][j], -p[ins[i][j]].h);
        }
        for (int j=0; j<(int)del[i].size(); j++) {
            ST.upd(ST.rt, 1, n, del[i][j], -INF);
        }

        int l=i-p[i].b, r=i-p[i].a;
        l=max(l, 1); r=max(l-1, r);

        if (l<=r) { ST.add(ST.rt, 1, n, l, r, p[i].h); }
        for (int j=0; j<(int)qq[i].size(); j++) {
            ans[qq[i][j].id]=max(ans[qq[i][j].id], ST.qrymx(ST.rt, 1, n, qq[i][j].l, i));
        }
        if (l<=r) { ST.add(ST.rt, 1, n, l, r, -p[i].h); }
    }
}

void sol2 ()
{
    for (int i=0; i<=n+1; i++) { del[i].clear(); ins[i].clear(); }

    for (int i=1; i<=n; i++) {
        int l=i-p[i].b, r=i-p[i].a;
        l=max(l, 1); r=max(l-1, r);
        if (l<=r) { del[l-1].push_back(i); ins[r].push_back(i); }

        for (int j=0; j<(int)qq[i].size(); j++) {
            qq2[qq[i][j].l].push_back((Qry){ i, qq[i][j].id });
        }
    }

    ST.build(ST.rt, 1, n);
    for (int i=n; i>=1; i--) {
        for (int j=0; j<(int)ins[i].size(); j++) {
            ST.upd(ST.rt, 1, n, ins[i][j], -p[ins[i][j]].h);
        }
        for (int j=0; j<(int)del[i].size(); j++) {
            ST.upd(ST.rt, 1, n, del[i][j], -INF);
        }

        int l=i+p[i].a, r=i+p[i].b;
        r=min(r, n); l=min(l, r+1);

        if (l<=r) { ST.add(ST.rt, 1, n, l, r, p[i].h); }
        for (int j=0; j<(int)qq2[i].size(); j++) {
            ans[qq2[i][j].id]=max(ans[qq2[i][j].id], ST.qrymx(ST.rt, 1, n, i, qq2[i][j].l));
        }
        if (l<=r) { ST.add(ST.rt, 1, n, l, r, -p[i].h); }
    }
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d", &n);
    for (int i=1; i<=n; i++) {
        scanf("%d %d %d", &p[i].h, &p[i].a, &p[i].b);
    }

    scanf("%d", &Q);
    for (int i=1; i<=Q; i++) {
        int l, r; scanf("%d %d", &l, &r);
        qq[r].push_back((Qry){ l, i });
        ans[i]=-1;
    }

    sol(); sol2();
    
    for (int i=1; i<=Q; i++) { printf("%d\n", ans[i]); }

    return 0;
}