```go
package main

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReader(os.Stdin)}
}

func (fs *FastScanner) NextInt() int {
	sign := 1
	val := 0
	c, _ := fs.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, _ = fs.r.ReadByte()
	}
	if c == '-' {
		sign = -1
		c, _ = fs.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int(c-'0')
		c, _ = fs.r.ReadByte()
	}
	return val * sign
}

type Edge struct {
	to int
	w  uint64
}

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

	t := in.NextInt()
	for ; t > 0; t-- {
		n := in.NextInt()
		a := in.NextInt()
		b := in.NextInt()

		adj := make([][]Edge, n+1)
		for i := 0; i < n-1; i++ {
			u := in.NextInt()
			v := in.NextInt()
			w := uint64(in.NextInt())
			adj[u] = append(adj[u], Edge{v, w})
			adj[v] = append(adj[v], Edge{u, w})
		}

		// Set of XORs from a without visiting b
		sA := make(map[uint64]struct{})
		type node struct {
			v int
			x uint64
		}

		vis := make([]bool, n+1)
		vis[b] = true
		stack := []node{{a, 0}}
		vis[a] = true
		sA[0] = struct{}{}
		for len(stack) > 0 {
			cur := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			for _, e := range adj[cur.v] {
				if !vis[e.to] {
					vis[e.to] = true
					nx := cur.x ^ e.w
					sA[nx] = struct{}{}
					stack = append(stack, node{e.to, nx})
				}
			}
		}

		// Set of XORs from b to all other nodes
		sB := make(map[uint64]struct{})
		vis2 := make([]bool, n+1)
		stack = []node{{b, 0}}
		vis2[b] = true
		for len(stack) > 0 {
			cur := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			for _, e := range adj[cur.v] {
				if !vis2[e.to] {
					vis2[e.to] = true
					nx := cur.x ^ e.w
					sB[nx] = struct{}{}
					stack = append(stack, node{e.to, nx})
				}
			}
		}

		ans := "NO"
		for x := range sA {
			if _, ok := sB[x]; ok {
				ans = "YES"
				break
			}
		}
		fmt.Fprintln(out, ans)
	}
}
```