```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

const INF = 1 << 60

type Node struct {
	tot int64
	pre int64
	suf int64
	sub int64
}

func NewNode(v int64) Node {
	return Node{v, v, v, v}
}

func Neutral() Node {
	return Node{0, -INF, -INF, -INF}
}

func Combine(l, r Node) Node {
	if l.sub == -INF {
		return r
	}
	if r.sub == -INF {
		return l
	}
	tot := l.tot + r.tot
	pre := max(l.pre, l.tot + r.pre)
	suf := max(r.suf, r.tot + l.suf)
	sub := max(l.sub, max(r.sub, l.suf + r.pre))
	return Node{tot, pre, suf, sub}
}

type SegTree struct {
	tree []Node
	n    int
}

func NewSegTree(size int) *SegTree {
	st := &SegTree{
		tree: make([]Node, 4*(size+1)),
		n:    size,
	}
	st.build(1, 1, size)
	return st
}

func (st *SegTree) build(node, tl, tr int) {
	if tl == tr {
		st.tree[node] = NewNode(0)
		return
	}
	tm := (tl + tr) / 2
	st.build(2*node, tl, tm)
	st.build(2*node+1, tm+1, tr)
	st.tree[node] = Combine(st.tree[2*node], st.tree[2*node+1])
}

func (st *SegTree) Query(node, tl, tr, ql, qr int) Node {
	if ql > tr || qr < tl {
		return Neutral()
	}
	if ql <= tl && tr <= qr {
		return st.tree[node]
	}
	tm := (tl + tr) / 2
	left := st.Query(2*node, tl, tm, ql, qr)
	right := st.Query(2*node+1, tm+1, tr, ql, qr)
	return Combine(left, right)
}

func (st *SegTree) Update(node, tl, tr, pos int, val int64) {
	if tl == tr {
		st.tree[node] = NewNode(val)
		return
	}
	tm := (tl + tr) / 2
	if pos <= tm {
		st.Update(2*node, tl, tm, pos, val)
	} else {
		st.Update(2*node+1, tm+1, tr, pos, val)
	}
	st.tree[node] = Combine(st.tree[2*node], st.tree[2*node+1])
}

func max(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

type QueryStruct struct {
	k, s, t, idx int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var N, M int
	fmt.Fscan(reader, &N, &M)
	L := make([]int, M+1)
	R := make([]int, M+1)
	X := make([]int64, M+1)
	for i := 1; i <= M; i++ {
		fmt.Fscan(reader, &L[i], &R[i], &X[i])
	}
	starts := make([][]int, N+2)
	ends := make([][]int, N+2)
	for i := 1; i <= M; i++ {
		starts[L[i]] = append(starts[L[i]], i)
		ends[R[i]] = append(ends[R[i]], i)
	}
	var Q int
	fmt.Fscan(reader, &Q)
	queries := make([]QueryStruct, Q)
	ans := make([]int64, Q)
	for q := 0; q < Q; q++ {
		var k, s, t int
		fmt.Fscan(reader, &k, &s, &t)
		queries[q] = QueryStruct{k, s, t, q}
	}
	sort.Slice(queries, func(i, j int) bool {
		return queries[i].k < queries[j].k
	})
	st := NewSegTree(M)
	qit := 0
	for k := 1; k <= N; k++ {
		for _, i := range starts[k] {
			st.Update(1, 1, M, i, X[i])
		}
		for qit < Q && queries[qit].k == k {
			s := queries[qit].s
			t := queries[qit].t
			idx := queries[qit].idx
			res := st.Query(1, 1, M, s, t)
			ans[idx] = res.sub
			qit++
		}
		for _, i := range ends[k] {
			st.Update(1, 1, M, i, 0)
		}
	}
	writer := bufio.NewWriter(os.Stdout)
	for _, a := range ans {
		fmt.Fprintln(writer, a)
	}
	writer.Flush()
}
```