```go
package main

import (
	"io"
	"os"
	"sort"
	"strconv"
)

type Bus struct {
	s  int
	f  int
	t  int
	id int
}

type Node struct {
	s []int
	f []int
}

var (
	tree    []Node
	buses   []Bus
	times   []int
	size    int
	nBus    int
	needPos int
	needL   int
	needR   int
)

func nextInt(data []byte, p *int) int {
	n := len(data)
	for *p < n && (data[*p] < '0' || data[*p] > '9') {
		*p++
	}
	val := 0
	for *p < n && data[*p] >= '0' && data[*p] <= '9' {
		val = val*10 + int(data[*p]-'0')
		*p++
	}
	return val
}

func lowerBound(a []int, x int) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] < x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func upperBound(a []int, x int) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] <= x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func exists(node int) bool {
	if len(tree[node].s) == 0 {
		return false
	}
	idx := upperBound(tree[node].s, needL) - 1
	return idx >= 0 && tree[node].f[idx] >= needR
}

func findFirst(node, nl, nr int) int {
	if nr < needPos || len(tree[node].s) == 0 {
		return -1
	}
	if !exists(node) {
		return -1
	}
	if nl == nr {
		if nl < nBus {
			return buses[nl].id
		}
		return -1
	}
	mid := (nl + nr) >> 1
	res := findFirst(node<<1, nl, mid)
	if res != -1 {
		return res
	}
	return findFirst(node<<1|1, mid+1, nr)
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0

	n := nextInt(data, &p)
	m := nextInt(data, &p)
	nBus = n

	buses = make([]Bus, n)
	for i := 0; i < n; i++ {
		s := nextInt(data, &p)
		f := nextInt(data, &p)
		t := nextInt(data, &p)
		buses[i] = Bus{s: s, f: f, t: t, id: i + 1}
	}

	sort.Slice(buses, func(i, j int) bool {
		return buses[i].t < buses[j].t
	})

	times = make([]int, n)
	for i := 0; i < n; i++ {
		times[i] = buses[i].t
	}

	size = 1
	for size < n {
		size <<= 1
	}

	tree = make([]Node, size<<1)
	for i := 0; i < n; i++ {
		idx := size + i
		tree[idx].s = []int{buses[i].s}
		tree[idx].f = []int{buses[i].f}
	}

	for i := size - 1; i >= 1; i-- {
		left := tree[i<<1]
		right := tree[i<<1|1]
		total := len(left.s) + len(right.s)
		if total == 0 {
			continue
		}
		sArr := make([]int, total)
		fArr := make([]int, total)
		a, b, k := 0, 0, 0
		for a < len(left.s) && b < len(right.s) {
			if left.s[a] <= right.s[b] {
				sArr[k] = left.s[a]
				fArr[k] = left.f[a]
				a++
			} else {
				sArr[k] = right.s[b]
				fArr[k] = right.f[b]
				b++
			}
			k++
		}
		for a < len(left.s) {
			sArr[k] = left.s[a]
			fArr[k] = left.f[a]
			a++
			k++
		}
		for b < len(right.s) {
			sArr[k] = right.s[b]
			fArr[k] = right.f[b]
			b++
			k++
		}
		tree[i].s = sArr
		tree[i].f = fArr
	}

	for i := 1; i < len(tree); i++ {
		for j := 1; j < len(tree[i].f); j++ {
			if tree[i].f[j] < tree[i].f[j-1] {
				tree[i].f[j] = tree[i].f[j-1]
			}
		}
	}

	out := make([]byte, 0, m*6)
	for i := 0; i < m; i++ {
		l := nextInt(data, &p)
		r := nextInt(data, &p)
		b := nextInt(data, &p)

		ans := -1
		pos := lowerBound(times, b)
		if pos < n {
			needPos = pos
			needL = l
			needR = r
			ans = findFirst(1, 0, size-1)
		}

		if i > 0 {
			out = append(out, ' ')
		}
		out = strconv.AppendInt(out, int64(ans), 10)
	}
	out = append(out, '\n')
	_, _ = os.Stdout.Write(out)
}
```