package main

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

type BIT struct {
	n     int
	mask  int
	qty   []int64
	cost  []int64
	stamp []int32
	cur   int32
}

func NewBIT(n int) *BIT {
	mask := 1
	for mask <= n {
		mask <<= 1
	}
	mask >>= 1
	return &BIT{
		n:     n,
		mask:  mask,
		qty:   make([]int64, n+2),
		cost:  make([]int64, n+2),
		stamp: make([]int32, n+2),
	}
}

func (b *BIT) add(idx int, q, c int64) {
	for idx <= b.n {
		if b.stamp[idx] != b.cur {
			b.stamp[idx] = b.cur
			b.qty[idx] = 0
			b.cost[idx] = 0
		}
		b.qty[idx] += q
		b.cost[idx] += c
		idx += idx & -idx
	}
}

func (b *BIT) lowerBound(target int64) int {
	pos := 0
	var sum int64
	bit := b.mask
	for bit > 0 {
		next := pos + bit
		if next <= b.n {
			var val int64
			if b.stamp[next] == b.cur {
				val = b.qty[next]
			}
			if sum+val < target {
				sum += val
				pos = next
			}
		}
		bit >>= 1
	}
	return pos + 1
}

func (b *BIT) prefix(idx int) (int64, int64) {
	var q, c int64
	for idx > 0 {
		if b.stamp[idx] == b.cur {
			q += b.qty[idx]
			c += b.cost[idx]
		}
		idx -= idx & -idx
	}
	return q, c
}

func (b *BIT) minCost(target int64) int64 {
	idx := b.lowerBound(target)
	q, c := b.prefix(idx - 1)
	return c + (target-q)*int64(idx)
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	ptr := 0
	nextInt := func() int {
		for ptr < len(data) && (data[ptr] < '0' || data[ptr] > '9') {
			ptr++
		}
		v := 0
		for ptr < len(data) && data[ptr] >= '0' && data[ptr] <= '9' {
			v = v*10 + int(data[ptr]-'0')
			ptr++
		}
		return v
	}

	n := nextInt()
	m := nextInt()

	adj := make([][]int, n+1)
	for i := 0; i < m; i++ {
		x := nextInt()
		y := nextInt()
		adj[x] = append(adj[x], y)
		adj[y] = append(adj[y], x)
	}

	w := nextInt()
	storeCity := make([]int, w)
	storeQty := make([]int64, w)
	storePrice := make([]int, w)
	maxPrice := 0
	for i := 0; i < w; i++ {
		c := nextInt()
		k := nextInt()
		p := nextInt()
		storeCity[i] = c
		storeQty[i] = int64(k)
		storePrice[i] = p
		if p > maxPrice {
			maxPrice = p
		}
	}

	q := nextInt()

	bit := NewBIT(maxPrice)
	dist := make([]int, n+1)
	queue := make([]int, n)
	cntDist := make([]int, n)
	start := make([]int, n)
	pos := make([]int, n)
	reachStore := make([]int, w)
	reachDist := make([]int, w)
	ordered := make([]int, w)

	out := make([]byte, 0, q*8)

	for qi := 0; qi < q; qi++ {
		g := nextInt()
		r := int64(nextInt())
		a := int64(nextInt())

		bit.cur++

		for i := 1; i <= n; i++ {
			dist[i] = -1
		}

		head, tail := 0, 0
		queue[tail] = g
		tail++
		dist[g] = 0

		for head < tail {
			v := queue[head]
			head++
			nd := dist[v] + 1
			for _, to := range adj[v] {
				if dist[to] == -1 {
					dist[to] = nd
					queue[tail] = to
					tail++
				}
			}
		}

		for i := 0; i < n; i++ {
			cntDist[i] = 0
		}

		reach := 0
		maxD := -1
		var totalReach int64

		for i := 0; i < w; i++ {
			d := dist[storeCity[i]]
			if d >= 0 {
				reachStore[reach] = i
				reachDist[reach] = d
				cntDist[d]++
				if d > maxD {
					maxD = d
				}
				totalReach += storeQty[i]
				reach++
			}
		}

		ans := -1

		if totalReach >= r && maxD >= 0 {
			start[0] = 0
			for d := 1; d <= maxD; d++ {
				start[d] = start[d-1] + cntDist[d-1]
			}
			for d := 0; d <= maxD; d++ {
				pos[d] = start[d]
			}
			for i := 0; i < reach; i++ {
				d := reachDist[i]
				ordered[pos[d]] = reachStore[i]
				pos[d]++
			}

			var totalQty int64
			for d := 0; d <= maxD; d++ {
				from := start[d]
				to := from + cntDist[d]
				for i := from; i < to; i++ {
					s := ordered[i]
					k := storeQty[s]
					p := storePrice[s]
					bit.add(p, k, k*int64(p))
					totalQty += k
				}
				if cntDist[d] > 0 && totalQty >= r {
					if bit.minCost(r) <= a {
						ans = d
						break
					}
				}
			}
		}

		out = strconv.AppendInt(out, int64(ans), 10)
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}