```go
package main

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

const INF = int64(1e18)

var dp []int64
var prev_x []int8
var taken []bool

func ensureCapacity(maxK int) {
	req := (maxK + 1) * 101
	if cap(dp) < req {
		dp = make([]int64, req)
		prev_x = make([]int8, req)
		taken = make([]bool, req)
	}
	if len(dp) < req {
		dp = dp[:req]
		prev_x = prev_x[:req]
		taken = taken[:req]
	}
}

type Option struct {
	id int
	t  int
	p  int
}

func solve(readInt func() int, out *bufio.Writer) {
	n := readInt()
	m := readInt()

	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		a[i] = readInt()
	}

	head := make([]int, n+1)
	for i := 1; i <= n; i++ {
		head[i] = -1
	}

	next := make([]int, m+1)
	opts := make([]Option, m+1)

	for i := 1; i <= m; i++ {
		e := readInt()
		t_val := readInt()
		p := readInt()
		opts[i] = Option{id: i, t: t_val, p: p}
		next[i] = head[e]
		head[e] = i
	}

	cum_time := int64(0)
	var ans []int
	possible := true

	taskOpts := make([]Option, 0, m)

	for e := 1; e <= n; e++ {
		taskOpts = taskOpts[:0]
		for i := head[e]; i != -1; i = next[i] {
			taskOpts = append(taskOpts, opts[i])
		}

		k := len(taskOpts)
		ensureCapacity(k)

		for x := 0; x <= 100; x++ {
			dp[x] = INF
		}
		dp[0] = 0

		for i := 0; i < k; i++ {
			opt := taskOpts[i]
			curr := i * 101
			nxt := (i + 1) * 101
			for x := 0; x <= 100; x++ {
				dp[nxt+x] = dp[curr+x]
				prev_x[nxt+x] = int8(x)
				taken[nxt+x] = false
			}
			for x := 0; x <= 100; x++ {
				if dp[curr+x] == INF {
					continue
				}
				nx := x + opt.p
				if nx > 100 {
					nx = 100
				}
				if dp[curr+x]+int64(opt.t) < dp[nxt+nx] {
					dp[nxt+nx] = dp[curr+x] + int64(opt.t)
					prev_x[nxt+nx] = int8(x)
					taken[nxt+nx] = true
				}
			}
		}

		if dp[k*101+100] == INF {
			possible = false
			break
		}

		cum_time += dp[k*101+100]
		if cum_time > int64(a[e]) {
			possible = false
			break
		}

		curr_x := 100
		for i := k - 1; i >= 0; i-- {
			nxt := (i + 1) * 101
			if taken[nxt+curr_x] {
				ans = append(ans, taskOpts[i].id)
			}
			curr_x = int(prev_x[nxt+curr_x])
		}
	}

	if !possible {
		fmt.Fprintln(out, "-1")
	} else {
		fmt.Fprintln(out, len(ans))
		for i, id := range ans {
			if i > 0 {
				fmt.Fprint(out, " ")
			}
			fmt.Fprint(out, id)
		}
		fmt.Fprintln(out)
	}
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1024*1024)
	out := bufio.NewWriterSize(os.Stdout, 1024*1024)
	defer out.Flush()

	var readInt func() int
	readInt = func() int {
		b, err := in.ReadByte()
		if err != nil {
			return 0
		}
		for b < '0' || b > '9' {
			b, err = in.ReadByte()
			if err != nil {
				return 0
			}
		}
		res := 0
		for b >= '0' && b <= '9' {
			res = res*10 + int(b-'0')
			b, err = in.ReadByte()
			if err != nil {
				break
			}
		}
		return res
	}

	T := readInt()
	for t := 0; t < T; t++ {
		solve(readInt, out)
	}
}
```