package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, m int
	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}

	colorEdges := make([][][2]int, m+1)
	for i := 0; i < m; i++ {
		var u, v, c int
		fmt.Fscan(in, &u, &v, &c)
		colorEdges[c] = append(colorEdges[c], [2]int{u, v})
	}

	compIDs := make([][]int, n+1)
	parent := make([]int, n+1)
	seen := make([]int, n+1)
	seenID := make([]int, n+1)
	id := make([]int, n+1)
	gen := 0
	compCount := 0

	for c := 1; c <= m; c++ {
		if len(colorEdges[c]) == 0 {
			continue
		}
		gen++
		var nodes []int
		for _, e := range colorEdges[c] {
			u, v := e[0], e[1]
			if seen[u] != gen {
				seen[u] = gen
				parent[u] = u
				nodes = append(nodes, u)
			}
			if seen[v] != gen {
				seen[v] = gen
				parent[v] = v
				nodes = append(nodes, v)
			}
			pu := u
			for parent[pu] != pu {
				parent[pu] = parent[parent[pu]]
				pu = parent[pu]
			}
			pv := v
			for parent[pv] != pv {
				parent[pv] = parent[parent[pv]]
				pv = parent[pv]
			}
			if pu != pv {
				parent[pu] = pv
			}
		}

		for _, v := range nodes {
			root := v
			for parent[root] != root {
				parent[root] = parent[parent[root]]
				root = parent[root]
			}
			if seenID[root] != gen {
				compCount++
				seenID[root] = gen
				id[root] = compCount
			}
			compIDs[v] = append(compIDs[v], id[root])
		}
	}

	var q int
	fmt.Fscan(in, &q)
	memo := make(map[int64]int)

	for k := 0; k < q; k++ {
		var u, v int
		fmt.Fscan(in, &u, &v)

		if u > v {
			u, v = v, u
		}
		key := int64(u)<<32 | int64(v)
		if ans, ok := memo[key]; ok {
			fmt.Fprintln(out, ans)
			continue
		}

		listU := compIDs[u]
		listV := compIDs[v]

		ans := 0
		i, j := 0, 0
		for i < len(listU) && j < len(listV) {
			if listU[i] == listV[j] {
				ans++
				i++
				j++
			} else if listU[i] < listV[j] {
				i++
			} else {
				j++
			}
		}
		memo[key] = ans
		fmt.Fprintln(out, ans)
	}
}