#include <bits/stdc++.h>
#define fi first
#define se second
#define multi false
#define gc getchar
#define pc putchar
#define pb push_back
#define ls (o * 2)
#define rs (o * 2 + 1)
#define int long long
#define pii pair<int, int>
#define debug(x) cout << #x << " " << x << '\n'
#define For(i, x, y) for (int i = (x); i <= (y); i++)
#define Rof(i, x, y) for (int i = (x); i >= (y); i--)
using namespace std;
inline int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}
inline int lcm(int a, int b) {
    return a * b / gcd(a, b);
}
int read(char ch = ' ', int x = 0, int w = 1) {
    while (!isdigit(ch)) {
        if (ch == '-') w = -1;
        ch = gc();
    }
    while (isdigit(ch)) { x = x * 10 + (ch - '0'), ch = gc(); }
    return x * w;
}
void read(int& x) {
    x = read();
}
void read(int n, int a[]) {
    For(i, 1, n) a[i] = read();
}
void read(int n, int a[], int b[]) {
    For(i, 1, n)
        a[i]
        = read(),
        b[i] = read();
}
void write(int x) {
    if (x < 0) x = -x, pc('-');
    if (x > 9) write(x / 10);
    pc(x % 10 + '0');
}
void write(int n, int a[]) { For(i, 1, n) write(a[i]), pc(' '); }
/*=============================================================================================================================================================================================*/
const int N = 1e5 + 10;
const int M = N << 2;
const int MIN = -1e15;
int t = 1, n, m, q, l, r, deta;
int ans[N];
bool debuG = false;
vector<pii> vec[N]; // first -> id; second -> deta
struct que {
    int l, r, id;
};
vector<que> Q[N];
struct seg {
    struct node {
        int Left = 0, Right = 0, Max = 0, Sum = 0;
    } Tree[M];
    node Add(node x, node y) {
        if (x.Left == MIN && x.Max == MIN && x.Right == MIN && x.Sum == MIN) return y;
        if (y.Left == MIN && y.Max == MIN && y.Right == MIN && y.Sum == MIN) return x;
        node ans;
        ans.Left = max(x.Left, x.Sum + y.Left);
        ans.Right = max(x.Right + y.Sum, y.Right);
        ans.Sum = x.Sum + y.Sum;
        ans.Max = max(max(ans.Left, ans.Right), max(max(x.Right, y.Left), x.Right + y.Left));
        return ans;
    }
    void pushup(int o) {
        Tree[o] = Add(Tree[ls], Tree[rs]);
        return;
    }
    void add(int o, int l, int r, int x, int deta) {
        if (l <= x && x <= r)
            ;
        else
            return;
        if (l == r) {
            Tree[o].Left = Tree[o].Right = Tree[o].Max = Tree[o].Sum = Tree[o].Sum + deta;
            return;
        }
        int mid = (l + r) >> 1;
        add(ls, l, mid, x, deta);
        add(rs, mid + 1, r, x, deta);
        pushup(o);
    }
    node query(int o, int l, int r, int L, int R) { // [L, R] query
        if ((L <= l && l <= R) || (L <= r && r <= R) || l <= L && L <= R && R <= r)
            ;
        else
            return { MIN, MIN, MIN, MIN };
        if (L <= l && l <= r && r <= R) return Tree[o];
        if (l == r) return { Tree[o].Left, Tree[o].Left, Tree[o].Left, Tree[o].Left };
        int mid = (l + r) >> 1;
        node LE = query(ls, l, mid, L, R);
        node RI = query(rs, mid + 1, r, L, R);
        // printf("query(%lld, %lld, %lld, %lld, %lld) = {%lld, %lld, %lld, %lld}\n", ls, l, mid, L, R, LE.Max, LE.Left, LE.Right, LE.Sum);
        // printf("query(%lld, %lld, %lld, %lld, %lld) = {%lld, %lld, %lld, %lld}\n", ls, mid + 1, r, L, R, RI.Max, RI.Left, RI.Right, RI.Sum);
        return Add(LE, RI);
    }
} Tree;
void solve() {
    read(n), read(m);
    For(i, 1, m) {
        read(l), read(r), read(deta);
        vec[l].push_back({ i, deta });
        vec[r + 1].push_back({ i, -deta });
    }
    read(q);
    For(i, 1, q) Q[read()].pb({ read(), read(), i });
    For(i, 1, n) {
        for (auto [id, val] : vec[i])
            Tree.add(1, 1, m, id, val);
        for (auto [l, r, id] : Q[i])
            ans[id] = Tree.query(1, 1, m, l, r).Max;
    }
    // debug(Tree.query(1, 1, m, 2, 9).Max); pc(10);
    // debug(Tree.query(1, 1, m, 2, 5).Left); pc(10);
    // debug(Tree.query(1, 1, m, 6, 9).Right); pc(10);
    For(i, 1, q)
        write(ans[i]),
        pc(10);
    return;
}
signed main() {
    if (multi) read(t);
    while (t--)
        solve();
    return 0;
}

8 36
1 1 -3
1 2 -2
1 3 2
1 4 6
1 5 -2
1 6 6
1 7 -4
1 8 6
2 2 -7
2 3 -1
2 4 0
2 5 -9
2 6 -7
2 7 -11
2 8 7
3 3 -19
3 4 9
3 5 -12
3 6 -9
3 7 -6
3 8 4
4 4 5
4 5 -4
4 6 -6
4 7 -3
4 8 -8
5 5 8
5 6 5
5 7 -18
5 8 -10
6 6 -18
6 7 0
6 8 -20
7 7 -9
7 8 5
8 8 9

1 

2 2 27

ans: 14 output: 12