package main

import (
	"io"
	"os"
	"strings"
)

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

	n := nextInt()
	log := 1
	for (1 << log) <= n {
		log++
	}

	up := make([][]int, log)
	for i := 0; i < log; i++ {
		up[i] = make([]int, n+1)
	}

	depth := make([]int, n+1)
	root := make([]int, n+1)
	partPref := make([]int, n+1)

	for i := 1; i <= n; i++ {
		p := nextInt()
		t := nextInt()
		if p == -1 {
			depth[i] = 0
			root[i] = i
			continue
		}
		depth[i] = depth[p] + 1
		root[i] = root[p]
		up[0][i] = p
		partPref[i] = partPref[p]
		if t == 1 {
			partPref[i]++
		}
		for k := 1; k < log; k++ {
			up[k][i] = up[k-1][up[k-1][i]]
		}
	}

	lca := func(a, b int) int {
		if depth[a] < depth[b] {
			a, b = b, a
		}
		diff := depth[a] - depth[b]
		for k := 0; k < log; k++ {
			if ((diff >> k) & 1) != 0 {
				a = up[k][a]
			}
		}
		if a == b {
			return a
		}
		for k := log - 1; k >= 0; k-- {
			if up[k][a] != up[k][b] {
				a = up[k][a]
				b = up[k][b]
			}
		}
		return up[0][a]
	}

	q := nextInt()
	var sb strings.Builder
	sb.Grow(q * 4)

	for ; q > 0; q-- {
		typ := nextInt()
		u := nextInt()
		v := nextInt()

		if root[u] != root[v] {
			sb.WriteString("NO\n")
			continue
		}

		w := lca(u, v)

		if typ == 1 {
			if w == u && w != v && partPref[v] == partPref[u] {
				sb.WriteString("YES\n")
			} else {
				sb.WriteString("NO\n")
			}
		} else {
			if w != v && partPref[u] == partPref[w] && partPref[v]-partPref[w] == depth[v]-depth[w] {
				sb.WriteString("YES\n")
			} else {
				sb.WriteString("NO\n")
			}
		}
	}

	os.Stdout.WriteString(sb.String())
}