```go
package main

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

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

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

	for i := 0; i < t; i++ {
		solve(reader, writer)
	}
}

func solve(r *bufio.Reader, w *bufio.Writer) {
	var n, a, b int
	fmt.Fscan(r, &n, &a, &b)

	adj := make([][]int, n+1)
	deg := make([]int, n+1)

	for i := 0; i < n; i++ {
		var u, v int
		fmt.Fscan(r, &u, &v)
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
		deg[u]++
		deg[v]++
	}

	if a == b {
		fmt.Fprintln(w, "NO")
		return
	}

	// Identify cycle nodes using topological sort (peeling leaves)
	q := make([]int, 0, n)
	for i := 1; i <= n; i++ {
		if deg[i] == 1 {
			q = append(q, i)
		}
	}

	onCycle := make([]bool, n+1)
	for i := 1; i <= n; i++ {
		onCycle[i] = true
	}

	head := 0
	for head < len(q) {
		u := q[head]
		head++
		onCycle[u] = false

		for _, v := range adj[u] {
			deg[v]--
			if deg[v] == 1 {
				q = append(q, v)
			}
		}
	}

	// BFS from b (Valeriu) to find the nearest cycle node (entry point)
	distB := make([]int, n+1)
	for i := 1; i <= n; i++ {
		distB[i] = -1
	}
	distB[b] = 0

	qB := make([]int, 0, n)
	qB = append(qB, b)

	entry := -1

	head = 0
	for head < len(qB) {
		u := qB[head]
		head++
		if onCycle[u] {
			entry = u
			break
		}
		for _, v := range adj[u] {
			if distB[v] == -1 {
				distB[v] = distB[u] + 1
				qB = append(qB, v)
			}
		}
	}

	distValeriu := distB[entry]

	// BFS from a (Marcel) to find distance to the same entry point
	distA := make([]int, n+1)
	for i := 1; i <= n; i++ {
		distA[i] = -1
	}
	distA[a] = 0

	qA := make([]int, 0, n)
	qA = append(qA, a)

	distMarcel := -1
	head = 0
	found := false
	for head < len(qA) {
		u := qA[head]
		head++
		if u == entry {
			distMarcel = distA[u]
			found = true
			break
		}
		for _, v := range adj[u] {
			if distA[v] == -1 {
				distA[v] = distA[u] + 1
				qA = append(qA, v)
			}
		}
	}

	// If Valeriu can reach the cycle strictly faster than Marcel can reach the entry point, he escapes.
	if found && distValeriu < distMarcel {
		fmt.Fprintln(w, "YES")
	} else {
		fmt.Fprintln(w, "NO")
	}
}
```