Alice and Bob are playing a fun game of tree tag.

The game is played on a tree of $n$ vertices numbered from $1$ to $n$. Recall that a tree on $n$ vertices is an undirected, connected graph with $n-1$ edges.

Initially, Alice is located at vertex $a$, and Bob at vertex $b$. They take turns alternately, and Alice makes the first move. In a move, Alice can jump to a vertex with distance at most $da$ from the current vertex. And in a move, Bob can jump to a vertex with distance at most $db$ from the current vertex. The distance between two vertices is defined as the number of edges on the unique simple path between them. In particular, either player is allowed to stay at the same vertex in a move. Note that when performing a move, a player only occupies the starting and ending vertices of their move, not the vertices between them.

If after at most $10^{100}$ moves, Alice and Bob occupy the same vertex, then Alice is declared the winner. Otherwise, Bob wins.

Determine the winner if both players play optimally.


-----Input-----

Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^4$). Description of the test cases follows.

The first line of each test case contains five integers $n,a,b,da,db$ ($2\le n\le 10^5$, $1\le a,b\le n$, $a\ne b$, $1\le da,db\le n-1$)  — the number of vertices, Alice's vertex, Bob's vertex, Alice's maximum jumping distance, and Bob's maximum jumping distance, respectively.

The following $n-1$ lines describe the edges of the tree. The $i$-th of these lines contains two integers $u$, $v$ ($1\le u, v\le n, u\ne v$), denoting an edge between vertices $u$ and $v$. It is guaranteed that these edges form a tree structure.

It is guaranteed that the sum of $n$ across all test cases does not exceed $10^5$.


-----Output-----

For each test case, output a single line containing the winner of the game: "Alice" or "Bob".


-----Example-----
Input
4
4 3 2 1 2
1 2
1 3
1 4
6 6 1 2 5
1 2
6 5
2 3
3 4
4 5
9 3 9 2 5
1 2
1 6
1 9
1 3
9 5
7 9
4 8
4 3
11 8 11 3 3
1 2
11 9
4 9
6 5
2 10
3 2
5 9
8 3
7 4
7 10

Output
Alice
Bob
Alice
Alice



-----Note-----

In the first test case, Alice can win by moving to vertex $1$. Then wherever Bob moves next, Alice will be able to move to the same vertex on the next move.

 [Image] 

In the second test case, Bob has the following strategy to win. Wherever Alice moves, Bob will always move to whichever of the two vertices $1$ or $6$ is farthest from Alice.

 [Image]

Difficulty: HARD
Tags: Tree algorithms

Dynamic programming

Graph traversal

Game theory
Skill types: Dynamic programming

Starter code:

Solutions:
import sys
from collections import deque as dq
input = sys.stdin.readline
for _ in range(int(input())):
	(N, a, b, da, db) = map(int, input().split())
	e = [[] for _ in range(N + 1)]
	for _ in range(N - 1):
		(u, v) = map(int, input().split())
		e[u].append(v)
		e[v].append(u)
	if da * 2 + 1 > db:
		print('Alice')
		continue
	Q = dq([a])
	inf = N + 1
	dpa = [inf] * (N + 1)
	dpa[a] = 0
	while len(Q):
		x = Q.popleft()
		for y in e[x]:
			if dpa[y] > dpa[x] + 1:
				dpa[y] = dpa[x] + 1
				Q.append(y)
	if dpa[b] <= da:
		print('Alice')
		continue
	far = a
	for v in range(1, N + 1):
		if dpa[far] < dpa[v]:
			far = v
	dp = [inf] * (N + 1)
	dp[far] = 0
	Q.append(far)
	while len(Q):
		x = Q.popleft()
		for y in e[x]:
			if dp[y] > dp[x] + 1:
				dp[y] = dp[x] + 1
				Q.append(y)
	dia = -(-max(dp[1:]) // 2)
	if dia <= da:
		print('Alice')
		continue
	print('Bob')


def dfs(x, p):
	l = 0
	for i in graph[x]:
		if i != p:
			depth[i] = depth[x] + 1
			cur = 1 + dfs(i, x)
			diam[0] = max(diam[0], cur + l)
			l = max(l, cur)
	return l
for _ in range(int(input())):
	(n, a, b, da, db) = [int(i) for i in input().split()]
	global graph
	graph = [[] for i in range(n)]
	for i in range(n - 1):
		(uu, vv) = [int(i) - 1 for i in input().split()]
		graph[uu].append(vv)
		graph[vv].append(uu)
	depth = [0] * n
	global diam
	diam = [0]
	temp = dfs(a - 1, -1)
	if 2 * da >= min(diam[0], db) or depth[b - 1] <= da:
		print('Alice')
	else:
		print('Bob')


def Diameter(x):
	v[x] = True
	stack = [x]
	while stack:
		a = stack.pop()
		for i in d[a]:
			if not v[i]:
				v[i] = True
				stack.append(i)
				dis[i] = dis[a] + 1

def BFS(a):
	v[a] = True
	q = [a]
	while q:
		p = q.pop(0)
		for i in d[p]:
			if not v[i]:
				q.append(i)
				v[i] = True
				distance[i] = distance[p] + 1
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	d = {i: [] for i in range(1, n + 1)}
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		d[x].append(y)
		d[y].append(x)
	dis = [0 for i in range(n + 1)]
	v = [False for i in range(n + 1)]
	Diameter(1)
	ans = float('-inf')
	for i in range(len(dis)):
		if dis[i] > ans:
			ans = dis[i]
			node = i
	dis = [0 for i in range(n + 1)]
	v = [False for i in range(n + 1)]
	Diameter(node)
	dia = float('-inf')
	for i in range(len(dis)):
		if dis[i] > dia:
			dia = dis[i]
	distance = [0 for i in range(n + 1)]
	v = [False for i in range(n + 1)]
	BFS(a)
	if distance[b] > da and 2 * da < dia and (db > 2 * da):
		print('Bob')
	else:
		print('Alice')


import sys
sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

def MI():
	return map(int, sys.stdin.readline().split())

def MI1():
	return map(int1, sys.stdin.readline().split())

def LI():
	return list(map(int, sys.stdin.readline().split()))

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]
for _ in range(II()):
	(n, a, b, da, db) = MI()
	(a, b) = (a - 1, b - 1)
	to = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = MI1()
		to[u].append(v)
		to[v].append(u)
	if db < da * 2 + 1:
		print('Alice')
		continue
	dist = [-1] * n
	dist[a] = 0
	stack = [a]
	while stack:
		u = stack.pop()
		for v in to[u]:
			if dist[v] != -1:
				continue
			dist[v] = dist[u] + 1
			stack.append(v)
	if dist[b] <= da:
		print('Alice')
		continue
	mx = max(dist)
	u = dist.index(mx)
	dist = [-1] * n
	dist[u] = 0
	stack = [u]
	while stack:
		u = stack.pop()
		for v in to[u]:
			if dist[v] != -1:
				continue
			dist[v] = dist[u] + 1
			stack.append(v)
	mx = max(dist)
	if mx >= da * 2 + 1:
		print('Bob')
	else:
		print('Alice')


def melysegi(x):
	latatlan.remove(int(x))
	for i in ellista[x]:
		if i in latatlan:
			melyseg[i] = melyseg[x] + 1
			melysegi(i)

def melysegi2(x):
	latatlan2.remove(int(x))
	for i in ellista[x]:
		if i in latatlan2:
			melyseg2[i] = melyseg2[x] + 1
			melysegi2(i)

def fa_atmero():
	vegpont = melyseg.index(max(melyseg))
	melysegi2(vegpont)
	atmero = max(melyseg2)
	return atmero
for _ in range(int(input())):
	(n, a, b, da, db) = list(map(int, input().split(' ')))
	ellista = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = [int(i) - 1 for i in input().split()]
		ellista[u].append(v)
		ellista[v].append(u)
	ellista = tuple(ellista)
	latatlan = set([i for i in range(0, n)])
	latatlan2 = set([i for i in range(0, n)])
	melyseg = [0] * n
	melyseg2 = [0] * n
	melysegi(a - 1)
	atmero = fa_atmero()
	if 2 * da < atmero and 2 * da < db and (melyseg[b - 1] > da):
		print('Bob')
	else:
		print('Alice')


import sys
input = sys.stdin.readline
t = int(input())
for rrr in range(t):
	(n, a, b, da, db) = list(map(int, input().split()))
	a -= 1
	b -= 1
	if da >= db:
		for _ in range(n - 1):
			(x, y) = list(map(int, input().split()))
		print('Alice')
	else:
		N = [[] for _ in range(n)]
		V = [0 for _ in range(n)]
		D = [0 for _ in range(n)]
		for _ in range(n - 1):
			(x, y) = list(map(int, input().split()))
			x -= 1
			y -= 1
			N[x].append(y)
			N[y].append(x)
		Q = [a]
		V[a] = 1
		depth = 0
		done = 0
		while Q:
			depth += 1
			new_Q = []
			for node in Q:
				for child in N[node]:
					if V[child] == 0:
						new_Q.append(child)
						V[child] = 1
						if child == b:
							if depth <= da:
								print('Alice')
								done = 1
			Q = new_Q
		if done == 0:
			V = [0 for _ in range(n)]
			Q = [0]
			OR = [0]
			V[0] = 1
			depth = 0
			while Q:
				new_Q = []
				for node in Q:
					for child in N[node]:
						if V[child] == 0:
							new_Q.append(child)
							V[child] = 1
							OR.append(child)
				Q = new_Q
				depth += 1
			Q = [OR[-1]]
			V = [0 for _ in range(n)]
			V[OR[-1]] = 1
			depth = 0
			while Q:
				new_Q = []
				for node in Q:
					for child in N[node]:
						if V[child] == 0:
							new_Q.append(child)
							V[child] = 1
							OR.append(child)
				Q = new_Q
				depth += 1
			depth -= 1
			if depth > 2 * da and db > 2 * da:
				print('Bob')
			else:
				print('Alice')


import sys
from math import sqrt
from collections import defaultdict
inpt = sys.stdin.readline

def inp():
	return int(inpt())

def inlist():
	return list(map(int, inpt().split()))

def instr():
	s = inpt()
	return list(s[:len(s) - 1])

def inbitstr():
	s = inpt()
	return [int(i) for i in list(s[:len(s) - 1])]

def invr():
	return map(int, inpt().split())

class Graph:

	def __init__(self, n):
		self.n = n
		self.graph = defaultdict(list)
		self.marked = defaultdict(int)

	def addEdge(self, u, v):
		self.graph[u].append(v)
		self.graph[v].append(u)

	def cleanup(self):
		self.marked = defaultdict(int)

	def dfs(self, u):
		self.marked[u] = 1
		(max, maxnode) = (0, u)
		for i in self.graph[u]:
			(cur, node) = (0, 0)
			if self.marked[i] == 0:
				(cur, node) = self.dfs(i)
			if cur > max:
				max = cur
				maxnode = node
		return (1 + max, maxnode)

	def lngdfs(self, u, v):
		self.marked[u] = 1
		max = self.n
		for i in self.graph[u]:
			if i == v:
				return 1
			cur = self.n
			if self.marked[i] == 0:
				cur = self.lngdfs(i, v)
			if cur < max:
				max = cur
		return 1 + max

def main():
	t = inp()
	for l in range(t):
		(n, a, b, da, db) = invr()
		g = Graph(n)
		for i in range(n - 1):
			(x, y) = invr()
			g.addEdge(x, y)
		(mx, v) = (0, 1)
		(mx, v) = g.dfs(v)
		g.cleanup()
		(mx, w) = g.dfs(v)
		g.cleanup()
		dist = g.lngdfs(a, b)
		alc = False
		if dist <= da:
			alc = True
		elif 2 * da >= db:
			alc = True
		elif 2 * da + 1 >= mx:
			alc = True
		if alc == True:
			print('Alice')
		else:
			print('Bob')
main()


import os
import heapq
import sys, threading
import math
import operator
from collections import defaultdict, deque
from io import BytesIO, IOBase
sys.setrecursionlimit(10 ** 5)

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def inpt():
	return [int(k) for k in input().split()]

def bfs1(d, node, n):
	visited = [False] * (n + 1)
	q = deque()
	q.append(node)
	visited[node] = True
	dist = [10000000000] * (n + 1)
	dist[node] = 0
	global mx
	while q:
		x = q.popleft()
		for i in d[x]:
			dist[i] = min(dist[i], dist[x] + 1)
			if dist[i] > mx:
				mx = dist[i]
			if not visited[i]:
				visited[i] = True
				q.append(i)

def bfs(d, s, n, b):
	visited = [False] * (n + 1)
	q = deque()
	q.append(s)
	visited[s] = True
	dist = [10000000000] * (n + 1)
	dist[s] = 0
	global mx, node
	while q:
		x = q.popleft()
		for i in d[x]:
			dist[i] = min(dist[i], dist[x] + 1)
			if dist[i] > mx:
				mx = dist[i]
				node = i
			if not visited[i]:
				visited[i] = True
				q.append(i)
	return dist[b]

def main():
	for _ in range(int(input())):
		(n, a, b, da, db) = inpt()
		d = defaultdict(list)
		for _ in range(n - 1):
			(u, v) = inpt()
			d[u].append(v)
			d[v].append(u)
		global mx, node
		mx = 0
		dist = bfs(d, a, n, b)
		mx = 0
		if dist <= da:
			print('Alice')
			continue
		bfs1(d, node, n)
		if mx <= 2 * da:
			print('Alice')
			continue
		if 2 * da < db:
			print('Bob')
			continue
		else:
			print('Alice')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from sys import stdin
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	go = [[] for _ in range(n)]
	for _ in range(n - 1):
		(x, y) = map(int, stdin.readline().split())
		x -= 1
		y -= 1
		go[x].append(y)
		go[y].append(x)
	MAX = 0

	def f(pre, node):
		global MAX
		re = [0, 0]
		for x in go[node]:
			if pre != x:
				re.append(f(node, x))
		re.sort()
		MAX = max(MAX, re[-1] + re[-2])
		return re[-1] + 1
	f(-1, 0)
	q = [(a, 0, -1)]
	while q != []:
		(node, level, pre) = q.pop()
		if node == b:
			dis = level
		MAX = max(MAX, level)
		for x in go[node]:
			if x != pre:
				q.append([x, level + 1, node])
	if dis <= da or da * 2 >= db or da * 2 >= MAX:
		print('Alice')
	else:
		print('Bob')


import sys
input = iter(sys.stdin.read().splitlines()).__next__

def furthest(graph, source):
	S = [(source, 0)]
	furthest_node = source
	furthest_dist = 0
	discovered = [False] * len(graph)
	while S:
		(u, dist) = S.pop()
		if dist > furthest_dist:
			furthest_node = u
			furthest_dist = dist
		if discovered[u]:
			continue
		discovered[u] = True
		for v in graph[u]:
			S.append((v, dist + 1))
	return (furthest_node, furthest_dist)

def distance(graph, source, dest):
	S = [(source, 0)]
	discovered = set()
	while S:
		(u, dist) = S.pop()
		if u == dest:
			return dist
		if u in discovered:
			continue
		discovered.add(u)
		for v in graph[u]:
			S.append((v, dist + 1))
t = int(input())
ans = []
for _ in range(t):
	(n, a, b, da, db) = map(int, input().split())
	if da + da >= db:
		for edge in range(n - 1):
			input()
		ans.append('Alice')
		continue
	graph = [[] for node in range(n)]
	for edge in range(n - 1):
		(u, v) = [int(i) - 1 for i in input().split()]
		graph[u].append(v)
		graph[v].append(u)
	if distance(graph, a - 1, b - 1) <= da:
		ans.append('Alice')
		continue
	diameter = furthest(graph, furthest(graph, 0)[0])[1]
	if da + da >= diameter:
		ans.append('Alice')
	else:
		ans.append('Bob')
print('\n'.join(ans))


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	(n, a, b, da, db) = map(int, input().split())
	EDGE = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		EDGE[x].append(y)
		EDGE[y].append(x)
	if db <= da * 2:
		print('Alice')
		continue
	Q = [a]
	USE = [-1] * (n + 1)
	USE[a] = 0
	while Q:
		x = Q.pop()
		for to in EDGE[x]:
			if USE[to] == -1:
				USE[to] = USE[x] + 1
				Q.append(to)
	if USE[b] <= da:
		print('Alice')
		continue
	MAX = -1
	MAXIND = -1
	for i in range(1, n + 1):
		if USE[i] > MAX:
			MAX = USE[i]
			MAXIND = i
	Q = [MAXIND]
	USE2 = [-1] * (n + 1)
	USE2[MAXIND] = 0
	while Q:
		x = Q.pop()
		for to in EDGE[x]:
			if USE2[to] == -1:
				USE2[to] = USE2[x] + 1
				Q.append(to)
	DIA = max(USE2)
	if DIA <= da * 2:
		print('Alice')
		continue
	else:
		print('Bob')


def solve(n, a, b, da, db, G):
	if 2 * da >= db:
		print('Alice')
		return
	dist = [-1] * n
	stk = [a]
	dist[a] = 0
	while stk:
		x = stk.pop()
		for y in G[x]:
			if dist[y] == -1:
				dist[y] = 1 + dist[x]
				stk.append(y)
	if dist[b] <= da:
		print('Alice')
		return
	x1 = dist.index(max(dist))
	dist = [-1] * n
	dist[x1] = 0
	stk = [x1]
	while stk:
		x = stk.pop()
		for y in G[x]:
			if dist[y] == -1:
				dist[y] = 1 + dist[x]
				stk.append(y)
	diameter = max(dist)
	if diameter <= 2 * da:
		print('Alice')
	else:
		print('Bob')
	return
for nt in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	G = [[] for _ in range(n)]
	for _ in range(n - 1):
		(x, y) = map(int, input().split())
		G[x - 1].append(y - 1)
		G[y - 1].append(x - 1)
	solve(n, a, b, da, db, G)


import sys
from collections import deque
input = sys.stdin.buffer.readline
T = int(input())
for t in range(T):
	(n, a, b, da, db) = map(int, input().split())
	e = [[] for _ in range(n + 1)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		e[u].append(v)
		e[v].append(u)
	par = [0] * (n + 1)
	(q, dep, order) = (deque([a]), [0] * (n + 1), [])
	while q:
		u = q.popleft()
		order.append(u)
		for v in e[u]:
			if v == par[u]:
				continue
			q.append(v)
			(par[v], dep[v]) = (u, dep[u] + 1)
	(dia, hei) = (0, [0] * (n + 1))
	for u in reversed(order):
		mxh = 0
		for v in e[u]:
			if v == par[u]:
				continue
			dia = max(dia, mxh + hei[v] + 1)
			mxh = max(mxh, hei[v] + 1)
		hei[u] = mxh
	if dep[b] <= da or db <= 2 * da or dia <= 2 * da:
		print('Alice')
	else:
		print('Bob')


from collections import deque

def dist(G, n, s):
	D = [None] * n
	Q = deque()
	Q.append(s)
	D[s] = 0
	while Q:
		f = Q.popleft()
		for t in G[f]:
			if D[t] is None:
				D[t] = D[f] + 1
				Q.append(t)
	return D
for ti in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	G = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		G[u - 1].append(v - 1)
		G[v - 1].append(u - 1)
	Da = dist(G, n, a)
	me = max(enumerate(Da), key=lambda x: x[1])[0]
	print('Alice') if Da[b] <= da or db <= 2 * da or max(dist(G, n, me)) <= 2 * da else print('Bob')


import sys
readline = sys.stdin.readline

def parorder(Edge, p):
	N = len(Edge)
	par = [0] * N
	par[p] = -1
	stack = [p]
	order = []
	visited = set([p])
	ast = stack.append
	apo = order.append
	while stack:
		vn = stack.pop()
		apo(vn)
		for vf in Edge[vn]:
			if vf in visited:
				continue
			visited.add(vf)
			par[vf] = vn
			ast(vf)
	return (par, order)

def getcld(p):
	res = [[] for _ in range(len(p))]
	for (i, v) in enumerate(p[1:], 1):
		res[v].append(i)
	return res
T = int(readline())
Ans = ['Bob'] * T
for qu in range(T):
	(N, fa, fb, da, db) = map(int, readline().split())
	fa -= 1
	fb -= 1
	Edge = [[] for _ in range(N)]
	for _ in range(N - 1):
		(a, b) = map(int, readline().split())
		a -= 1
		b -= 1
		Edge[a].append(b)
		Edge[b].append(a)
	if 2 * da >= db:
		Ans[qu] = 'Alice'
		continue
	stack = [fa]
	dist = [0] * N
	used = set([fa])
	while stack:
		vn = stack.pop()
		for vf in Edge[vn]:
			if vf not in used:
				used.add(vf)
				dist[vf] = dist[vn] + 1
				stack.append(vf)
	if dist[fb] <= da:
		Ans[qu] = 'Alice'
		continue
	left = dist.index(max(dist))
	stack = [left]
	dist = [0] * N
	used = set([left])
	while stack:
		vn = stack.pop()
		for vf in Edge[vn]:
			if vf not in used:
				used.add(vf)
				dist[vf] = dist[vn] + 1
				stack.append(vf)
	D = max(dist)
	if 2 * da >= D:
		Ans[qu] = 'Alice'
print('\n'.join(Ans))


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, a, b, da, db) = map(int, input().split())
	g = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		g[u - 1].append(v - 1)
		g[v - 1].append(u - 1)
	a -= 1
	b -= 1
	d0 = [0] * n
	q = [[-1, 0]]
	while q:
		(par, ver) = q.pop()
		for to in g[ver]:
			if par != to:
				d0[to] = d0[ver] + 1
				q.append([ver, to])
	p = d0.index(max(d0))
	q = [[-1, p]]
	d = [0] * n
	while q:
		(par, ver) = q.pop()
		for to in g[ver]:
			if par != to:
				d[to] = d[ver] + 1
				q.append([ver, to])
	R = max(d)
	q = [[-1, a]]
	d1 = [0] * n
	while q:
		(par, ver) = q.pop()
		for to in g[ver]:
			if par != to:
				d1[to] = d1[ver] + 1
				q.append([ver, to])
	ab = d1[b]
	if ab <= da:
		print('Alice')
	elif 2 * da >= R:
		print('Alice')
	elif db > 2 * da:
		print('Bob')
	else:
		print('Alice')


import sys

def input():
	return sys.stdin.readline().strip()

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 19
MOD = 10 ** 9 + 7

def dfs(nodes, src):
	N = len(nodes)
	stack = [(src, -1)]
	dist = [INF] * N
	dist[src] = 0
	while stack:
		(u, prev) = stack.pop()
		for v in nodes[u]:
			if v != prev:
				dist[v] = dist[u] + 1
				stack.append((v, u))
	return dist
for _ in range(INT()):
	(N, a, b, da, db) = MAP()
	a -= 1
	b -= 1
	nodes = [[] for i in range(N)]
	for i in range(N - 1):
		(x, y) = MAP()
		x -= 1
		y -= 1
		nodes[x].append(y)
		nodes[y].append(x)
	dist = dfs(nodes, a)[b]
	if da * 2 + 1 > db or dist <= da:
		print('Alice')
		continue
	res1 = dfs(nodes, 0)
	t = res1.index(max(res1))
	res2 = dfs(nodes, t)
	mx = max(res2)
	if da * 2 + 1 > mx:
		print('Alice')
	else:
		print('Bob')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

def lcm(a, b):
	return a * b // gcd(a, b)

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
from collections import deque

def bfs(graph, alpha=0):
	n = len(graph)
	q = deque([alpha])
	used = [False] * n
	used[alpha] = True
	(dist, parents) = ([0] * n, [-1] * n)
	while q:
		v = q.popleft()
		for u in graph[v]:
			if not used[u]:
				used[u] = True
				q.append(u)
				dist[u] = dist[v] + 1
				parents[u] = v
	return (used, dist, parents)

def shortest_path(graph, alpha, omega):
	(used, dist, parents) = bfs(graph, alpha)
	if not used[omega]:
		return []
	path = [omega]
	v = omega
	while parents[v] != -1:
		path += [parents[v]]
		v = parents[v]
	return path[::-1]
for _ in range(int(input()) if True else 1):
	(n, a, b, da, db) = map(int, input().split())
	graph = [[] for __ in range(n + 1)]
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		graph[x] += [y]
		graph[y] += [x]
	(u, d, p) = bfs(graph, 1)
	ma = max(d)
	for i in range(len(d)):
		if d[i] == ma:
			break
	(u, d, p) = bfs(graph, i)
	di = max(d)
	(u, d, p) = bfs(graph, a)
	dist = d[b]
	print('Alice' if dist <= da or min(2 * da, di) >= min(db, di) else 'Bob')


from collections import deque
from sys import stdin

def input():
	return stdin.readline().strip()
t = int(input())
for case in range(t):
	(n, a, b, da, db) = map(int, input().split())
	graph = dict()
	for i in range(1, n + 1):
		graph[i] = []
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].append(v)
		graph[v].append(u)
	if db <= 2 * da:
		print('Alice')
		continue
	dist = [0] * (n + 1)
	visited = [False] * (n + 1)
	q = deque()
	q.append(a)
	visited[a] = True
	while q:
		curr = q.popleft()
		for neighbor in graph[curr]:
			if visited[neighbor] == False:
				visited[neighbor] = True
				q.append(neighbor)
				dist[neighbor] = dist[curr] + 1
	if dist[b] <= da:
		print('Alice')
		continue
	maxDist = 0
	nodeMax = -1
	for i in range(1, n + 1):
		if dist[i] > maxDist:
			maxDist = dist[i]
			nodeMax = i
	q = deque()
	dist = [0] * (n + 1)
	q.append(nodeMax)
	visited = [False] * (n + 1)
	visited[nodeMax] = True
	while q:
		curr = q.popleft()
		for neighbor in graph[curr]:
			if visited[neighbor] == False:
				visited[neighbor] = True
				q.append(neighbor)
				dist[neighbor] = dist[curr] + 1
	if max(dist) <= 2 * da:
		print('Alice')
		continue
	print('Bob')


from collections import deque
tests = int(input())
for testnum in range(tests):
	[n, a, b, da, db] = list(map(int, input().split()))
	edges = [[] for _ in range(n + 1)]
	for _ in range(n - 1):
		[u, v] = list(map(int, input().split()))
		edges[u].append(v)
		edges[v].append(u)

	def shortestpath_bf(start, end):
		q = deque()
		indicators = [None for _ in range(n + 1)]
		q.append(start)
		indicators[start] = 0
		maxnode = None
		maxdist = -1
		while len(q) > 0:
			node = q.pop()
			for nebors in edges[node]:
				if indicators[nebors] is None:
					indicators[nebors] = indicators[node] + 1
					q.append(nebors)
					if indicators[nebors] > maxdist:
						maxdist = indicators[nebors]
						maxnode = nebors
		return (maxnode, maxdist, indicators[end])
	temp = shortestpath_bf(a, b)
	separation = temp[2]
	temp = shortestpath_bf(temp[0], 0)
	diameter = temp[1]
	if db <= 2 * da:
		print('Alice')
	elif separation <= da:
		print('Alice')
	elif diameter <= 2 * da:
		print('Alice')
	else:
		print('Bob')


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush, heappop, heapify
import math
from collections import *
from functools import reduce, cmp_to_key
import sys
input = sys.stdin.readline
from itertools import accumulate
from functools import lru_cache
M = mod = 10000

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip('\n').split()]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
distbetween = g = 0

def dfs(node, v=-1):
	global g, distbetween
	d = deque()
	d.append([node, 0])
	maxdist = 0
	farnode = node
	visited = {}
	while d:
		(node, dist) = d.popleft()
		visited[node] = 1
		if node == v and distbetween == None:
			distbetween = dist
		if dist > maxdist:
			(maxdist, farnode) = (dist, node)
		for j in g[node]:
			if j not in visited:
				visited[j] = 1
				d.append([j, dist + 1])
	return [farnode, maxdist]
for _ in range(val()):
	(n, a, b, da, db) = li()
	g = defaultdict(set)
	distbetween = None
	for i in range(n - 1):
		(u, v) = li()
		g[u].add(v)
		g[v].add(u)
	farnode1 = dfs(a, b)[0]
	diameter = dfs(farnode1)[1]
	print('Bob' if distbetween > da and diameter > 2 * da and (2 * da < db) else 'Alice')


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for pp in range(t):
		solve(pp)

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def google(p):
	print('Case #' + str(p) + ': ', end='')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def bfs(g, st):
	visited = [-1] * len(g)
	visited[st] = 0
	queue = deque([])
	queue.append(st)
	new = []
	while len(queue) != 0:
		s = queue.popleft()
		new.append(s)
		for i in g[s]:
			if visited[i] == -1:
				visited[i] = visited[s] + 1
				queue.append(i)
	return visited

def solve(case):
	(n, aa, bb, da, db) = sep()
	g = [[] for i in range(n)]
	for i in range(n - 1):
		(a, b) = sep()
		a -= 1
		b -= 1
		g[a].append(b)
		g[b].append(a)
	dist = bfs(g, 0)
	ind = 0
	for i in range(n):
		if dist[i] > dist[ind]:
			ind = i
	dist = bfs(g, ind)
	ans = 0
	for i in range(n):
		ans = max(ans, dist[i])
	dist = bfs(g, aa - 1)
	if dist[bb - 1] <= da or ans <= 2 * da or db <= 2 * da:
		print('Alice')
	else:
		print('Bob')
testcase(int(inp()))


import sys
readline = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
	return int(readline())

def read_int_n():
	return list(map(int, readline().split()))

def read_float():
	return float(readline())

def read_float_n():
	return list(map(float, readline().split()))

def read_str():
	return readline().strip()

def read_str_n():
	return readline().strip().split()

def error_print(*args):
	print(*args, file=sys.stderr)

def mt(f):
	import time

	def wrap(*args, **kwargs):
		s = time.perf_counter()
		ret = f(*args, **kwargs)
		e = time.perf_counter()
		error_print(e - s, 'sec')
		return ret
	return wrap
from collections import defaultdict
from functools import reduce

@mt
def slv(N, A, B, DA, DB, UV):
	if 2 * DA >= DB:
		return 'Alice'
	g = defaultdict(list)
	for (u, v) in UV:
		g[u].append(v)
		g[v].append(u)

	def dfs(u):
		d = {u: 0}
		s = [u]
		while s:
			u = s.pop()
			for v in g[u]:
				if v in d:
					continue
				d[v] = d[u] + 1
				s.append(v)
		return d
	d = dfs(A)
	if d[B] <= DA:
		return 'Alice'
	mv = reduce(lambda m, i: max(m, (d[i], i)), d.keys(), (-INF, -1))
	d = dfs(mv[1])
	diam = max(d.values())
	if 2 * DA >= diam:
		return 'Alice'
	return 'Bob'

def main():
	for _ in range(read_int()):
		(N, A, B, DA, DB) = read_int_n()
		UV = [read_int_n() for _ in range(N - 1)]
		print(slv(N, A, B, DA, DB, UV))
main()


import sys
input = sys.stdin.readline
import collections
from collections import defaultdict

def bfs1(graph, root):
	dist = [0] * (n + 1)
	(visited, queue) = (set(), collections.deque([root]))
	visited.add(root)
	while queue:
		vertex = queue.popleft()
		for neighbour in graph[vertex]:
			if neighbour not in visited:
				dist[neighbour] = dist[vertex] + 1
				visited.add(neighbour)
				queue.append(neighbour)
	return (vertex, dist)

def bfs2(graph, root):
	status = [True] * 10005
	count = -2
	(visited, queue) = (set(), collections.deque([None, root]))
	visited.add(root)
	while queue:
		vertex = queue.popleft()
		if vertex is None:
			count += 1
			queue.append(None)
			if len(queue) == 1:
				break
			else:
				continue
		for neighbour in graph[vertex]:
			if neighbour not in visited:
				visited.add(neighbour)
				queue.append(neighbour)
	return count
t = int(input())
for ii in range(t):
	(n, a, b, da, db) = map(int, input().split())
	graph = defaultdict(list)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].append(v)
		graph[v].append(u)
	(corner, dist) = bfs1(graph, a)
	if dist[b] <= da:
		sys.stdout.write('Alice' + '\n')
	else:
		output = bfs2(graph, corner)
		if min(db, output) <= 2 * da:
			sys.stdout.write('Alice' + '\n')
		else:
			sys.stdout.write('Bob' + '\n')


import sys
ii = lambda : sys.stdin.readline().strip()
idata = lambda : [int(x) for x in ii().split()]

def dfs(graph, ver):
	used = set()
	level = [ver]
	depth = [0] * (len(graph) + 1)
	levels_number = 0
	while level:
		new_level = []
		for vertex in level:
			used.add(vertex)
			depth[vertex] = levels_number
			for new_vertex in graph[vertex]:
				if new_vertex not in used:
					new_level += [new_vertex]
		levels_number += 1
		level = new_level[:]
	return depth

def solve():
	(n, a, b, da, db) = idata()
	graph = {}
	for i in range(n - 1):
		(v, u) = idata()
		if not v in graph:
			graph[v] = [u]
		else:
			graph[v] += [u]
		if not u in graph:
			graph[u] = [v]
		else:
			graph[u] += [v]
	depth = dfs(graph, a)
	k = max(depth)
	for i in range(len(depth)):
		if depth[i] == k:
			a = i
			break
	diametr = max(dfs(graph, a))
	if diametr <= 2 * da or depth[b] <= da or 2 * da >= db:
		print('Alice')
	else:
		print('Bob')
	return
for t in range(int(ii())):
	solve()


from collections import deque
import sys
input = sys.stdin.readline

def get_diameter(tree):
	(u, _, _) = _dfs(0, tree)
	(v, diam, dist) = _dfs(u, tree)
	path = [v]
	while v != u:
		for nxt_v in tree[v]:
			if 1 + dist[nxt_v] == dist[v]:
				path.append(nxt_v)
				v = nxt_v
				break
	return (diam, path)

def _dfs(start, tree):
	n = len(tree)
	dist = [-1] * n
	dist[start] = 0
	stack = [start]
	while stack:
		v = stack.pop()
		for nxt_v in tree[v]:
			if dist[nxt_v] != -1:
				continue
			dist[nxt_v] = dist[v] + 1
			stack.append(nxt_v)
	max_d = max(dist)
	return (dist.index(max_d), max_d, dist)

def ab(a, b):
	INF = 10 ** 6
	visited = [INF] * n
	visited[a] = 0
	q = deque([a])
	while q:
		v = q.popleft()
		for nxt_v in tree[v]:
			if visited[v] + 1 < visited[nxt_v]:
				visited[nxt_v] = visited[v] + 1
				q.append(nxt_v)
	return visited[b]
t = int(input())
for _ in range(t):
	(n, a, b, da, db) = map(int, input().split())
	edges = [list(map(int, input().split())) for i in range(n - 1)]
	a -= 1
	b -= 1
	if da * 2 >= db:
		print('Alice')
		continue
	tree = [[] for i in range(n)]
	for (u, v) in edges:
		u -= 1
		v -= 1
		tree[u].append(v)
		tree[v].append(u)
	distance = ab(a, b)
	if distance <= da:
		print('Alice')
		continue
	(d, _) = get_diameter(tree)
	d += 1
	db = da * 2 + 2
	if d >= db:
		print('Bob')
	else:
		print('Alice')


from collections import deque

def dfs(x):
	length[x] = 0
	queue = deque()
	queue.append(x)
	while queue:
		y = queue.popleft()
		for z in t[y]:
			if length[z] is None:
				length[z] = length[y] + 1
				queue.append(z)
for _ in range(int(input())):
	(n, a, b, da, db) = list(map(int, input().split()))
	t = [[] for i in range(n)]
	for x in range(n - 1):
		(u, v) = list(map(int, input().split()))
		t[u - 1].append(v - 1)
		t[v - 1].append(u - 1)
	length = [None] * n
	dfs(a - 1)
	lb = length[b - 1]
	mx = max(length)
	nex = length.index(mx)
	length = [None] * n
	dfs(nex)
	if da >= lb or 2 * da >= db or 2 * da >= max(length):
		print('Alice')
	else:
		print('Bob')


from collections import deque
A = int(input())
ans = ['Bob'] * A
for t in range(A):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	edge = [[] for _ in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		edge[u - 1].append(v - 1)
		edge[v - 1].append(u - 1)
	visited = [False] * n
	d = deque()
	visited[a] = True
	d.append((a, 0))
	while len(d) > 0:
		(v, cnt) = d.popleft()
		for w in edge[v]:
			if visited[w] == False:
				visited[w] = True
				if w == b:
					dist = cnt + 1
				d.append((w, cnt + 1))
	if dist <= da:
		ans[t] = 'Alice'
		continue
	visited = [False] * n
	d = deque()
	visited[v] = True
	d.append((v, 0))
	while len(d) > 0:
		(v, cnt) = d.popleft()
		for w in edge[v]:
			if visited[w] == False:
				visited[w] = True
				d.append((w, cnt + 1))
	if min(cnt, db) <= da * 2:
		ans[t] = 'Alice'
print(*ans, sep='\n')


import sys
LI = lambda : list(map(int, sys.stdin.readline().strip('\n').split()))
MI = lambda : map(int, sys.stdin.readline().strip('\n').split())
SI = lambda : sys.stdin.readline().strip('\n')
II = lambda : int(sys.stdin.readline().strip('\n'))
for _ in range(II()):
	(n, a, b, da, db) = MI()
	g = {i: [] for i in range(1, n + 1)}
	for __ in range(n - 1):
		(u, v) = MI()
		g[u].append(v)
		g[v].append(u)
	vis = [False] * (n + 1)
	dist = [0] * (n + 1)
	q = [a]
	(m1, v1) = (0, 0)
	while q:
		u = q.pop()
		vis[u] = True
		for v in g[u]:
			if not vis[v]:
				dist[v] = dist[u] + 1
				if dist[v] > m1:
					m1 = dist[v]
					v1 = v
				q.append(v)
	distab = dist[b]
	vis = [False] * (n + 1)
	dist = [0] * (n + 1)
	q = [v1]
	diam = 0
	while q:
		u = q.pop()
		vis[u] = True
		for v in g[u]:
			if not vis[v]:
				dist[v] = dist[u] + 1
				if dist[v] > diam:
					diam = dist[v]
					v1 = v
				q.append(v)
	if distab <= da:
		print('Alice')
	elif 2 * da >= diam:
		print('Alice')
	elif db > 2 * da:
		print('Bob')
	else:
		print('Alice')


from bisect import *
from collections import *
from math import gcd, ceil, sqrt, floor, inf
from heapq import *
from itertools import *
from operator import add, mul, sub, xor, truediv, floordiv
from functools import *
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())
from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc
farr = [1]
ifa = []

def fact(x, mod=0):
	if mod:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr) % mod)
	else:
		while x >= len(farr):
			farr.append(farr[-1] * len(farr))
	return farr[x]

def ifact(x, mod):
	global ifa
	ifa.append(pow(farr[-1], mod - 2, mod))
	for i in range(x, 0, -1):
		ifa.append(ifa[-1] * i % mod)
	ifa = ifa[::-1]

def per(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return fact(i) // fact(i - j)
	return farr[i] * ifa[i - j] % mod

def com(i, j, mod=0):
	if i < j:
		return 0
	if not mod:
		return per(i, j) // fact(j)
	return per(i, j, mod) * ifa[j] % mod

def catalan(n):
	return com(2 * n, n) // (n + 1)

def linc(f, t, l, r):
	while l < r:
		mid = (l + r) // 2
		if t > f(mid):
			l = mid + 1
		else:
			r = mid
	return l

def rinc(f, t, l, r):
	while l < r:
		mid = (l + r + 1) // 2
		if t < f(mid):
			r = mid - 1
		else:
			l = mid
	return l

def ldec(f, t, l, r):
	while l < r:
		mid = (l + r) // 2
		if t < f(mid):
			l = mid + 1
		else:
			r = mid
	return l

def rdec(f, t, l, r):
	while l < r:
		mid = (l + r + 1) // 2
		if t > f(mid):
			r = mid - 1
		else:
			l = mid
	return l

def isprime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def binfun(x):
	c = 0
	for w in arr:
		c += ceil(w / x)
	return c

def lowbit(n):
	return n & -n

def inverse(a, m):
	a %= m
	if a <= 1:
		return a
	return (1 - inverse(m, a) * m) // a % m

class BIT:

	def __init__(self, arr):
		self.arr = arr
		self.n = len(arr) - 1

	def update(self, x, v):
		while x <= self.n:
			self.arr[x] += v
			x += x & -x

	def query(self, x):
		ans = 0
		while x:
			ans += self.arr[x]
			x &= x - 1
		return ans

class smt:

	def __init__(self, l, r, arr):
		self.l = l
		self.r = r
		self.value = (1 << 31) - 1 if l < r else arr[l]
		mid = (l + r) // 2
		if l < r:
			self.left = smt(l, mid, arr)
			self.right = smt(mid + 1, r, arr)
			self.value &= self.left.value & self.right.value

	def setvalue(self, x, val):
		if self.l == self.r:
			self.value = val
			return
		mid = (self.l + self.r) // 2
		if x <= mid:
			self.left.setvalue(x, val)
		else:
			self.right.setvalue(x, val)
		self.value = self.left.value & self.right.value

	def ask(self, l, r):
		if l <= self.l and r >= self.r:
			return self.value
		val = (1 << 31) - 1
		mid = (self.l + self.r) // 2
		if l <= mid:
			val &= self.left.ask(l, r)
		if r > mid:
			val &= self.right.ask(l, r)
		return val

class DSU:

	def __init__(self, n):
		self.c = [-1] * n

	def same(self, x, y):
		return self.find(x) == self.find(y)

	def find(self, x):
		if self.c[x] < 0:
			return x
		self.c[x] = self.find(self.c[x])
		return self.c[x]

	def union(self, u, v):
		(u, v) = (self.find(u), self.find(v))
		if u == v:
			return False
		if self.c[u] < self.c[v]:
			(u, v) = (v, u)
		self.c[u] += self.c[v]
		self.c[v] = u
		return True

	def size(self, x):
		return -self.c[self.find(x)]

class UFS:

	def __init__(self, n):
		self.parent = [i for i in range(n)]
		self.ranks = [0] * n

	def find(self, x):
		if x != self.parent[x]:
			self.parent[x] = self.find(self.parent[x])
		return self.parent[x]

	def union(self, u, v):
		(pu, pv) = (self.find(u), self.find(v))
		if pu == pv:
			return False
		if self.ranks[pu] >= self.ranks[pv]:
			self.parent[pv] = pu
			if self.ranks[pv] == self.ranks[pu]:
				self.ranks[pu] += 1
		else:
			self.parent[pu] = pv

def Prime(n):
	c = 0
	prime = []
	flag = [0] * (n + 1)
	for i in range(2, n + 1):
		if not flag[i]:
			prime.append(i)
			c += 1
		for j in range(c):
			if i * prime[j] > n:
				break
			flag[i * prime[j]] = prime[j]
			if i % prime[j] == 0:
				break
	return prime

def dij(s, graph):
	d = {}
	d[s] = 0
	heap = [(0, s)]
	seen = set()
	while heap:
		(dis, u) = heappop(heap)
		if u in seen:
			continue
		for v in graph[u]:
			if v not in d or d[v] > d[u] + graph[u][v]:
				d[v] = d[u] + graph[u][v]
				heappush(heap, (d[v], v))
	return d

def GP(it):
	return [(ch, len(list(g))) for (ch, g) in groupby(it)]

class DLN:

	def __init__(self, val):
		self.val = val
		self.pre = None
		self.next = None

@bootstrap
def dfs(r, p, d):
	global flag
	if r == b - 1:
		if d <= da:
			flag = True
		yield None
	for child in g[r]:
		if child != p:
			yield dfs(child, r, d + 1)
			if flag:
				break
	yield None

@bootstrap
def dfs2(r, p):
	if len(g[r]) == 1 and p != -1:
		yield 1
	(fi, se) = (0, 0)
	global ma
	for child in g[r]:
		if child != p:
			tmp = (yield dfs2(child, r))
			if tmp >= fi:
				(fi, se) = (tmp, fi)
			elif tmp > se:
				se = tmp
	ma = max(ma, fi + se)
	yield (fi + 1)
t = N()
for i in range(t):
	(n, a, b, da, db) = RL()
	g = [[] for _ in range(n)]
	for i in range(n - 1):
		(u, v) = RL()
		g[u - 1].append(v - 1)
		g[v - 1].append(u - 1)
	if db < 2 * da + 1:
		ans = 'Alice'
	else:
		flag = False
		dfs(a - 1, -1, 0)
		if flag:
			ans = 'Alice'
		else:
			ans = 'Alice'
			ma = 1
			dfs2(a - 1, -1)
			if ma >= 2 * da + 1:
				ans = 'Bob'
	print(ans)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def RL():
	return map(int, sys.stdin.readline().rstrip().split())

def RLL():
	return list(map(int, sys.stdin.readline().rstrip().split()))

def N():
	return int(input())

def print_list(l):
	print(' '.join(map(str, l)))
from collections import Counter
from collections import defaultdict as dc
for _ in range(int(input())):
	(n, a, b, da, db) = RL()
	dic = dc(set)
	for _ in range(n - 1):
		(u, v) = RL()
		dic[v].add(u)
		dic[u].add(v)
	if not db > da * 2:
		print('Alice')
	else:
		used = {a}
		now = dic[a]
		dab = 0
		flag = True
		while 1:
			if flag:
				dab += 1
				if b in now:
					flag = False
			nex = set()
			for node in now:
				nex.update(dic[node])
			nex -= used
			if not nex:
				break
			used.update(now)
			now = nex
		if dab <= da:
			print('Alice')
		else:
			k = now.pop()
			used = {k}
			now = dic[k]
			md = 1
			while 1:
				md += 1
				nex = set()
				for node in now:
					nex.update(dic[node])
				nex -= used
				if not nex:
					break
				used.update(now)
				now = nex
			if da * 2 + 1 >= md:
				print('Alice')
			else:
				print('Bob')


for t in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	graph = [set() for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].add(v)
		graph[v].add(u)
	visited = {1}
	last_visits = set()
	visit_now = {1}
	while len(visited) < n:
		while visit_now:
			i = visit_now.pop()
			last_visits |= graph[i] - visited
			visited |= graph[i]
		visit_now = last_visits
		last_visits = set()
	last = visit_now.pop()
	visited = {last}
	last_visits = set()
	visit_now = {last}
	N = 1
	while len(visited) < n:
		N += 1
		while visit_now:
			i = visit_now.pop()
			last_visits |= graph[i] - visited
			visited |= graph[i]
		visit_now = last_visits
		last_visits = set()
	visited = {a}
	last_visits = set()
	visit_now = {a}
	dist = 0
	while not b in visit_now:
		dist += 1
		while visit_now:
			i = visit_now.pop()
			last_visits |= graph[i] - visited
			visited |= graph[i]
		visit_now = last_visits
		last_visits = set()
	if db < 2 * da + 1:
		print('Alice')
	elif 2 * da + 1 >= N:
		print('Alice')
	elif dist <= da:
		print('Alice')
	else:
		print('Bob')


from collections import defaultdict

class Graph:

	def __init__(self, vertices):
		self.graph = [defaultdict() for _ in range(vertices)]
		self.V = vertices

	def add_edge(self, u, v, w=1):
		self.graph[u][v] = w
		self.graph[v][u] = w

	def dfs(self, u, dist, d=0):
		dist[u] = d
		for v in self.graph[u]:
			if dist[v] == None:
				self.dfs(v, dist, d + 1)
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	g = Graph(n)
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		g.add_edge(u - 1, v - 1)
	dist = [None] * n
	g.dfs(a, dist)
	if dist[b] <= da:
		print('Alice')
	else:
		f = dist.index(max(dist))
		dist_n = [None] * n
		g.dfs(f, dist_n)
		dia = max(dist_n)
		if 2 * da >= dia:
			print('Alice')
		elif db <= 2 * da:
			print('Alice')
		else:
			print('Bob')


from collections import deque
for j in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	d = [list() for i in range(n)]
	for i in range(n - 1):
		(c, e) = map(int, input().split())
		c -= 1
		e -= 1
		d[c].append(e)
		d[e].append(c)
	a -= 1
	b -= 1
	if db < 2 * da:
		print('Alice')
	else:
		v = set()
		v.add(a)
		q = deque([[a, 0]])
		while q:
			p = q.popleft()
			if p[0] == b:
				l = p[1]
				break
			for x in d[p[0]]:
				if x not in v:
					q.append([x, p[1] + 1])
					v.add(x)
		if l <= da:
			print('Alice')
		else:
			z = set()
			z.add(0)
			dist = [0] * n
			q = deque([[0, 0]])
			while q:
				p = q.popleft()
				for x in d[p[0]]:
					if x not in z:
						z.add(x)
						dist[x] = p[1] + 1
						q.append([x, p[1] + 1])
			u = 0
			for i in range(n):
				if dist[i] > dist[u]:
					u = i
			dist[u] = 0
			y = set()
			y.add(u)
			q = deque([[u, 0]])
			while q:
				p = q.popleft()
				for x in d[p[0]]:
					if x not in y:
						y.add(x)
						dist[x] = p[1] + 1
						q.append([x, p[1] + 1])
			g = 0
			for i in range(n):
				if dist[i] > dist[g]:
					g = i
			if dist[g] > 2 * da and db > 2 * da:
				print('Bob')
			else:
				print('Alice')


import sys
input = lambda : sys.stdin.readline().rstrip()
from collections import deque
T = int(input())
for _ in range(T):
	(N, a, b, da, db) = list(map(int, input().split()))
	(a, b) = (a - 1, b - 1)
	X = [[] for _ in range(N)]
	Y = [[] for _ in range(N)]
	for _ in range(N - 1):
		(u, v) = list(map(int, input().split()))
		X[u - 1].append(v - 1)
		X[v - 1].append(u - 1)
		Y[u - 1].append(v - 1)
		Y[v - 1].append(u - 1)
	if 2 * da >= db:
		print('Alice')
		continue
	P = [-1] * N
	Q = deque([a])
	R = []
	D = [0] * N
	while Q:
		i = deque.popleft(Q)
		R.append(i)
		for j in X[i]:
			if j != P[i]:
				P[j] = i
				D[j] = D[i] + 1
				X[j].remove(i)
				deque.append(Q, j)
	if D[b] <= da:
		print('Alice')
		continue
	ma = max(D)
	for i in range(N):
		if D[i] == ma:
			break
	X = Y
	P = [-1] * N
	Q = deque([i])
	R = []
	D = [0] * N
	while Q:
		i = deque.popleft(Q)
		R.append(i)
		for j in X[i]:
			if j != P[i]:
				P[j] = i
				D[j] = D[i] + 1
				X[j].remove(i)
				deque.append(Q, j)
	print('Bob' if max(D) > 2 * da else 'Alice')


import os, sys
from io import BytesIO, IOBase
from collections import defaultdict, deque
from copy import deepcopy

def longest_path(path, n):
	st = [1]
	depth = [[0, 0] for _ in range(n + 1)]
	ans = 0
	while len(st):
		if not len(path[st[-1]]):
			x = depth[st.pop()]
			ans = max(ans, sum(x))
			if len(st):
				y = depth[st[-1]]
				if y[0] < x[0] + 1:
					(y[1], y[0]) = (y[0], x[0] + 1)
				elif y[1] < x[0] + 1:
					y[1] = x[0] + 1
			continue
		i = path[st[-1]].pop()
		path[i].remove(st[-1])
		st.append(i)
	return ans

def road(a, b, path, com):
	st = [a]
	ans = 0
	while len(st):
		if not len(path[st[-1]]):
			ans -= 1
			st.pop()
			continue
		x = path[st[-1]].pop()
		path[x].remove(st[-1])
		st.append(x)
		ans += 1
		if x == b:
			return True if ans <= com else False

def main():
	for _ in range(int(input())):
		(n, a, b, da, db) = map(int, input().split())
		path = defaultdict(set)
		for _ in range(n - 1):
			(u, v) = map(int, input().split())
			path[u].add(v)
			path[v].add(u)
		path1 = deepcopy(path)
		d = longest_path(path, n)
		x = road(a, b, path1, da)
		if min(d, db) > 2 * da and (not x):
			print('Bob')
		else:
			print('Alice')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from sys import stdin
from collections import deque
input = stdin.readline
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	idx = []
	for x in range(n + 1):
		idx.append(set())
	for x in range(n - 1):
		(xx, yy) = map(int, input().split())
		idx[xx].add(yy)
		idx[yy].add(xx)
	chk = [0] * (n + 1)
	(q, qc) = (deque(), deque())
	q.append(1)
	qc.append(0)
	m = 0
	chk[1] = 1
	ii = 1
	while len(q):
		(now, nowc) = (q.popleft(), qc.popleft())
		for x in idx[now]:
			if chk[x] == 1:
				continue
			chk[x] = 1
			q.append(x)
			qc.append(nowc + 1)
			if nowc + 1 > m:
				ii = x
				m = nowc + 1
	chk = [0] * (n + 1)
	(q, qc) = (deque(), deque())
	q.append(ii)
	qc.append(0)
	m = 0
	chk[ii] = 1
	while len(q):
		(now, nowc) = (q.popleft(), qc.popleft())
		for x in idx[now]:
			if chk[x] == 1:
				continue
			chk[x] = 1
			q.append(x)
			qc.append(nowc + 1)
			if nowc + 1 > m:
				m = nowc + 1
	chk = [0] * (n + 1)
	(q, qc) = (deque(), deque())
	q.append(a)
	qc.append(0)
	chk[a] = 1
	(da, db) = (min(da, m), min(db, m))
	while len(q):
		(now, nowc) = (q.popleft(), qc.popleft())
		if nowc + 1 > da:
			break
		for x in idx[now]:
			if chk[x] == 1:
				continue
			chk[x] = 1
			q.append(x)
			qc.append(nowc + 1)
	if chk[b] == 1:
		print('Alice')
		continue
	if da >= db - 1:
		print('Alice')
		continue
	if 2 * da + 1 <= db:
		print('Bob')
	else:
		print('Alice')


import sys
input = sys.stdin.readline
from collections import deque
(T,) = map(int, input().split())
for _ in range(T):
	(N, a, b, da, db) = map(int, input().split())
	d = [set() for _ in range(N + 1)]
	for _ in range(N - 1):
		(v, u) = map(int, input().split())
		d[v].add(u)
		d[u].add(v)
	queue = deque([a])
	vs = set([a])
	dist = [0] * (N + 1)
	vs_bfs = list()
	while queue:
		v = queue.popleft()
		vs_bfs.append(v)
		for u in d[v]:
			if u in vs:
				continue
			vs.add(u)
			queue.append(u)
			dist[u] = dist[v] + 1
	if dist[b] <= da:
		print('Alice')
		continue
	bb = vs_bfs[-1]
	queue = deque([bb])
	vs = set([bb])
	dist = [0] * (N + 1)
	vs_bfs = list()
	while queue:
		v = queue.popleft()
		vs_bfs.append(v)
		for u in d[v]:
			if u in vs:
				continue
			vs.add(u)
			queue.append(u)
			dist[u] = dist[v] + 1
	x = dist[vs_bfs[-1]]
	if db > da * 2 and x > da * 2:
		print('Bob')
	else:
		print('Alice')


from sys import stdin, stdout

def tree_tag(n, a, b, da, db, dic):
	dis = distance(a, -1, b, dic)
	if dis <= da:
		return 'Alice'
	ln1 = dfs(1, -1, dic)
	ln2 = dfs(ln1[0], -1, dic)
	mxpath = ln2[1]
	if da * 2 < db and mxpath > da * 2:
		return 'Bob'
	return 'Alice'

def distance(node, pnode, b, dic):
	if node == b:
		return 0
	for nxt in dic[node]:
		if nxt != pnode:
			wk = distance(nxt, node, b, dic)
			if wk != -1:
				return 1 + wk
	return -1

def dfs(node, pnode, dic):
	sub = [-1, -1]
	for nxt in dic[node]:
		if nxt != pnode:
			wk = dfs(nxt, node, dic)
			if wk[1] > sub[1]:
				sub = wk
	if sub[0] != -1:
		return [sub[0], sub[1] + 1]
	else:
		return [node, 0]
t = int(stdin.readline())
for _ in range(t):
	(n, a, b, da, db) = map(int, stdin.readline().split())
	dic = {}
	for _ in range(n - 1):
		(u, v) = map(int, stdin.readline().split())
		if u not in dic:
			dic[u] = []
		if v not in dic:
			dic[v] = []
		dic[u].append(v)
		dic[v].append(u)
	ans = tree_tag(n, a, b, da, db, dic)
	stdout.write(ans + '\n')


from sys import stdin, stdout
from math import gcd, sqrt, factorial, pi
from collections import deque, defaultdict
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
L = lambda : list(R())
P = lambda x: stdout.write(x)
lcm = lambda x, y: x * y // gcd(x, y)
hg = lambda x, y: (y + x - 1) // x * x
pw = lambda x: 1 if x == 1 else 1 + pw(x // 2)
chk = lambda x: chk(x // 2) if not x % 2 else True if x == 1 else False
sm = lambda x: (x ** 2 + x) // 2
N = 10 ** 9 + 7

def dfs(a, n, ind, des, flg):
	v = [0] * n
	stk = [ind]
	v[ind] = 1
	vst = [1] * n
	vst[ind] = 0
	while stk:
		x = stk.pop()
		for el in a[x]:
			if vst[el]:
				v[el] = v[x] + 1
				stk += (el,)
				vst[el] = 0
	return [max(v), v.index(max(v)), v[des] if flg else 0]
for _ in range(I()):
	(n, a, b, da, db) = R()
	v = [[] for i in range(n)]
	for i in range(n - 1):
		(x, y) = R()
		v[x - 1] += (y - 1,)
		v[y - 1] += (x - 1,)
	ind = dfs(v, n, 0, 0, False)[1]
	ans = dfs(v, n, ind, 0, False)[0]
	in_d = dfs(v, n, a - 1, b - 1, True)[2]
	db = min(db + 1, ans)
	if db <= 2 * da + 1 or in_d <= da + 1:
		print('Alice')
	else:
		print('Bob')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import deque, defaultdict
for j in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	tree = [set([]) for s in range(n)]
	for s in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		tree[u].add(v)
		tree[v].add(u)
	a -= 1
	b -= 1
	queue = deque([a])
	vis = set([a])
	fur = a
	cv = 0
	pr = 1
	dist = 0
	while len(queue) > 0:
		v0 = queue.popleft()
		for s in tree[v0]:
			if not s in vis:
				queue.append(s)
				vis.add(s)
				fur = s
				if s == b:
					dist = cv + 1
		pr -= 1
		if pr == 0:
			cv += 1
			pr = len(queue)
	if dist <= da:
		print('Alice')
	elif db < 2 * da + 1:
		print('Alice')
	else:
		stack = [fur]
		longest = 1
		while len(stack) > 0:
			v1 = stack[-1]
			if len(tree[v1]) > 0:
				v2 = tree[v1].pop()
				stack.append(v2)
				tree[v2].discard(v1)
			else:
				longest = max(longest, len(stack))
				stack.pop()
		if longest <= 2 * da + 1:
			print('Alice')
		else:
			print('Bob')


from sys import stdin, gettrace
from collections import deque
if gettrace():
	inputi = input
else:

	def input():
		return next(stdin)[:-1]

	def inputi():
		return stdin.buffer.readline()

def readGraph(n, m):
	adj = [[] for _ in range(n)]
	for _ in range(m):
		(u, v) = map(int, inputi().split())
		adj[u - 1].append(v - 1)
		adj[v - 1].append(u - 1)
	return adj

def readTree(n):
	return readGraph(n, n - 1)

def treeOrderByDepth(n, adj, root=0):
	parent = [-1] * n
	depth = [0] * n
	parent[root] = -2
	ordered = []
	q = deque()
	q.append(root)
	while q:
		c = q.popleft()
		ordered.append(c)
		for a in adj[c]:
			if parent[a] == -1:
				parent[a] = c
				depth[a] = depth[c] + 1
				q.append(a)
	return (ordered, parent, depth)

def solve():
	(n, a, b, da, db) = map(int, inputi().split())
	adj = readTree(n)
	(ob, pb, depthb) = treeOrderByDepth(n, adj, b - 1)
	if depthb[a - 1] <= da:
		print('Alice')
		return
	if db <= 2 * da:
		print('Alice')
		return
	if depthb[ob[-1]] > 2 * da:
		print('Bob')
		return
	(ox, px, depthx) = treeOrderByDepth(n, adj, ob[-1])
	if depthx[ox[-1]] <= 2 * da:
		print('Alice')
		return
	print('Bob')

def main():
	t = int(inputi())
	for _ in range(t):
		solve()
main()


from collections import deque
import sys
input = sys.stdin.readline

def bfs(start, g, visited):
	q = deque([start])
	visited[start] = 0
	last_node = 0
	while q:
		curr_node = q.popleft()
		for next_node in g[curr_node]:
			if visited[next_node] >= 0:
				continue
			visited[next_node] = visited[curr_node] + 1
			q.append(next_node)
			last_node = next_node
	return last_node
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	if a == b:
		print('Alice')
		continue
	gl = [[] for _ in range(n + 1)]
	visited = [-1] * (n + 1)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		gl[u].append(v)
		gl[v].append(u)
	node_a = bfs(a, gl, visited)
	if visited[b] <= da:
		print('Alice')
		continue
	visited = [-1] * (n + 1)
	node_b = bfs(node_a, gl, visited)
	dia = visited[node_b]
	db = min(db, dia)
	if db > 2 * da:
		print('Bob')
	else:
		print('Alice')


from sys import stdin, stdout
get_string = lambda : stdin.readline().strip('\n')
get_intmap = lambda : map(int, get_string().split(' '))

def testcase():
	(n, a, b, da, db) = get_intmap()
	adj = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = get_intmap()
		adj[u].append(v)
		adj[v].append(u)
	used = [0] * (n + 1)
	(frontier, nxt, used[a], distance) = ([a], [], 1, 0)
	while len(frontier):
		distance += 1
		for u in frontier:
			for v in adj[u]:
				if used[v]:
					continue
				if v == b:
					distance_ab = distance
				used[v] = 1
				nxt.append(v)
		if nxt == []:
			leaf_node = frontier.pop()
		(frontier, nxt) = (nxt, [])
	if distance_ab <= da:
		print('Alice')
		return
	used = [0] * (n + 1)
	(frontier, nxt, used[leaf_node], distance) = ([leaf_node], [], 1, 0)
	while len(frontier):
		distance += 1
		for u in frontier:
			for v in adj[u]:
				if used[v]:
					continue
				used[v] = 1
				nxt.append(v)
		if nxt == []:
			tree_diameter = distance - 1
		(frontier, nxt) = (nxt, [])
	if tree_diameter <= 2 * da:
		print('Alice')
		return
	if db <= 2 * da:
		print('Alice')
	else:
		print('Bob')
for t in range(int(input())):
	testcase()


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def dfs(node, c):
	dist[node] = c
	vis[node] = 1
	for j in edge[node]:
		if vis[j] == 0:
			dfs(j, c + 1)
t = int(input())
for _ in range(t):
	(n, a, b, x, y) = list(map(int, input().split()))
	edge = [[] for i in range(n + 1)]
	for j in range(n - 1):
		(u, v) = list(map(int, input().split()))
		edge[u].append(v)
		edge[v].append(u)
	dist = [0] * (n + 1)
	vis = [0] * (n + 1)
	if y < 2 * x + 1:
		print('Alice')
	else:
		dfs(a, 0)
		arr = []
		for i in range(n + 1):
			arr.append(dist[i])
		if dist[b] <= x:
			print('Alice')
		else:
			temp = max(dist)
			ind = dist.index(temp)
			dist = [0] * (n + 1)
			vis = [0] * (n + 1)
			dfs(ind, 0)
			maxi = max(dist)
			if maxi < 2 * x + 1:
				print('Alice')
			else:
				print('Bob')


import sys
ii = lambda : sys.stdin.readline().strip()
idata = lambda : [int(x) for x in ii().split()]

def bfs(graph, start_ver):
	visited = set()
	queue = [[start_ver, 0]]
	visited.add(start_ver)
	(ans_way_length, ans_ver) = (0, start_ver)
	while queue:
		ver = queue.pop(0)
		for new_ver in graph[ver[0]]:
			if new_ver not in visited:
				visited.add(new_ver)
				queue += [[new_ver, ver[1] + 1]]
				if ans_way_length < ver[1] + 1:
					(ans_ver, ans_way_length) = (new_ver, ver[1] + 1)
	return (ans_ver, ans_way_length)

def solve():
	(n, a, b, da, db) = idata()
	graph = {}
	for i in range(n - 1):
		(v, u) = idata()
		if not v in graph:
			graph[v] = [u]
		else:
			graph[v] += [u]
		if not u in graph:
			graph[u] = [v]
		else:
			graph[u] += [v]
	used = set()
	s1 = [a]
	d = [0] * (n + 1)
	l = 0
	while s1:
		s2 = []
		for i in s1:
			used.add(i)
			d[i] = l
			for j in graph[i]:
				if j not in used:
					s2 += [j]
		l += 1
		s1 = s2[:]
	a = 0
	q = d[b]
	k = max(d)
	for i in range(len(d)):
		if d[i] == k:
			a = i
			break
	used = set()
	s1 = [a]
	d = [0] * (n + 1)
	l = 0
	while s1:
		s2 = []
		for i in s1:
			used.add(i)
			d[i] = l
			for j in graph[i]:
				if j not in used:
					s2 += [j]
		l += 1
		s1 = s2[:]
	if max(d) <= 2 * da or q <= da or 2 * da >= db:
		print('Alice')
	else:
		print('Bob')
	return
for t in range(int(ii())):
	solve()


import sys

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())

def solve():
	(n, a, b, da, db) = mints()
	e = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = mints()
		e[u].append(v)
		e[v].append(u)
	if db < da * 2 + 1:
		return False
	q = [0] * (n + 2)
	ql = 0
	qr = 1
	d = [None] * (n + 1)
	d[a] = 0
	q[0] = a
	while ql < qr:
		x = q[ql]
		ql += 1
		for v in e[x]:
			if d[v] is None:
				d[v] = d[x] + 1
				q[qr] = v
				qr += 1
	if d[b] <= da:
		return False
	far = q[qr - 1]
	if d[far] >= da * 2 + 1:
		return True
	ql = 0
	qr = 1
	d = [None] * (n + 1)
	d[far] = 0
	q[0] = far
	while ql < qr:
		x = q[ql]
		ql += 1
		for v in e[x]:
			if d[v] is None:
				d[v] = d[x] + 1
				q[qr] = v
				qr += 1
	far2 = q[qr - 1]
	return d[far2] >= da * 2 + 1
for i in range(mint()):
	print(['Alice', 'Bob'][solve()])


import sys
from math import ceil
from collections import deque
input = sys.stdin.buffer.readline

def print(val):
	sys.stdout.write(str(val) + '\n')
for _ in range(int(input())):
	(n, a, b, da, db) = [int(i) for i in input().split()]
	adj = [[] for i in range(n + 1)]
	mark = [0] * (n + 1)
	d = [0] * (n + 1)
	for i in range(n - 1):
		(v, u) = [int(i) for i in input().split()]
		adj[v].append(u)
		adj[u].append(v)
	q = deque()
	q.append(a)
	d[a] = 0
	mark[a] = 1
	s = a
	while q:
		s = q.popleft()
		for i in adj[s]:
			if mark[i] == 0:
				d[i] = d[s] + 1
				q.append(i)
				mark[i] = 1
	dd = [0] * (n + 1)
	mark = [0] * (n + 1)
	q = deque()
	q.append(s)
	dd[s] = 0
	longest = 0
	mark[s] = 1
	while q:
		s = q.popleft()
		for i in adj[s]:
			if mark[i] == 0:
				dd[i] = dd[s] + 1
				q.append(i)
				mark[i] = 1
				longest = dd[i]
	if da >= d[b] or db < 2 * da + 1 or longest < 2 * da + 1:
		print('Alice')
	else:
		print('Bob')


from collections import deque

def get_(d, a):
	l = [-1] * (n + 1)
	q = deque()
	q.append(a)
	l[a] = 0
	while q:
		x = q.popleft()
		for y in d[x]:
			if l[y] == -1:
				l[y] = l[x] + 1
				flag = 1
				q.append(y)
	return l
t = int(input())
for _ in range(t):
	(n, a, b, da, db) = list(map(int, input().split()))
	d = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(x, y) = list(map(int, input().split()))
		d[x].append(y)
		d[y].append(x)
	l = get_(d, a)
	index = max(enumerate(l), key=lambda x: x[1])[0]
	l_ = get_(d, index)
	if max(l_) <= 2 * da or db <= 2 * da or l[b] <= da:
		print('Alice')
	else:
		print('Bob')


import sys as _sys
ALICE = 'Alice'
BOB = 'Bob'
MAX_GRAPH_SIZE = 10 ** 5

def main():
	t = int(input())
	for i in range(t):
		(n, a, b, da, db) = _read_ints()
		a -= 1
		b -= 1
		graph = [set() for v in range(n)]
		for i in range(n - 1):
			(u, v) = _read_ints()
			u -= 1
			v -= 1
			graph[u].add(v)
			graph[v].add(u)
		winner = who_wins(graph=graph, alice_start_vertex=a, alice_speed=da, bob_start_vertex=b, bob_speed=db)
		print(winner)

def _read_line():
	return _sys.stdin.readline()

def _read_ints():
	return map(int, _read_line().split(' '))

def who_wins(*, graph, alice_start_vertex, bob_start_vertex, alice_speed, bob_speed):
	assert len(graph) <= MAX_GRAPH_SIZE
	distance = find_distance(alice_start_vertex, bob_start_vertex, graph)
	v_1 = find_farthest_vertices(0, graph)[0].pop()
	max_vertices_distance = find_farthest_vertices(v_1, graph)[1]
	if alice_speed >= distance:
		winner = ALICE
	elif 2 * alice_speed + 1 >= max_vertices_distance + 1:
		winner = ALICE
	elif bob_speed >= 2 * alice_speed + 1:
		winner = BOB
	else:
		winner = ALICE
	return winner

def find_distance(vertex_1, vertex_2, graph):
	passed = {vertex_1}
	distance = 0
	candidates = graph[vertex_1]
	while vertex_2 not in passed:
		new_candidates = set()
		for candidate in candidates:
			passed.add(candidate)
			new_candidates |= graph[candidate] - passed
		candidates = new_candidates
		distance += 1
	return distance

def find_farthest_vertices(vertex, graph):
	passed = {vertex}
	distance = 0
	candidates = graph[vertex]
	while True:
		new_candidates = set()
		for candidate in candidates:
			passed.add(candidate)
			new_candidates |= graph[candidate] - passed
		if not new_candidates:
			return (candidates, distance + 1)
		candidates = new_candidates
		distance += 1
main()


import sys
import math
from collections import deque
input = sys.stdin.readline

def bfs(root):
	depth[root] = 0
	q = deque([root])
	while q:
		root = q.popleft()
		for ver in A[root]:
			if depth[ver] is not None:
				continue
			depth[ver] = depth[root] + 1
			q.append(ver)
T = int(input())
for t in range(T):
	(n, a, b, da, db) = map(int, input().split(' '))
	a -= 1
	b -= 1
	A = [[] for i in range(n)]
	depth = [None for i in range(n)]
	for i in range(n - 1):
		(x, y) = map(int, input().split(' '))
		x -= 1
		y -= 1
		A[x].append(y)
		A[y].append(x)
	bfs(a)
	if depth[b] <= da:
		print('Alice')
		continue
	max_depth = -1
	max_depth_vertex = None
	for i in range(n):
		if depth[i] > max_depth:
			max_depth = depth[i]
			max_depth_vertex = i
	depth = [None for i in range(n)]
	bfs(max_depth_vertex)
	diameter = max(depth)
	if da * 2 >= diameter:
		print('Alice')
		continue
	if db > da * 2:
		print('Bob')
	else:
		print('Alice')


import sys, bisect, string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, groupby
rep = range
R = range

def Golf():
	(n, *t) = map(int, open(0).read().split())

def I():
	return int(input())

def S_():
	return input()

def IS():
	return input().split()

def LS():
	return [i for i in input().split()]

def MI():
	return map(int, input().split())

def LI():
	return [int(i) for i in input().split()]

def LI_():
	return [int(i) - 1 for i in input().split()]

def NI(n):
	return [int(input()) for i in range(n)]

def NI_(n):
	return [int(input()) - 1 for i in range(n)]

def NLI(n):
	return [[int(i) for i in input().split()] for i in range(n)]

def NLI_(n):
	return [[int(i) - 1 for i in input().split()] for i in range(n)]

def StoLI():
	return [ord(i) - 97 for i in input()]

def ItoS(n):
	return chr(n + 97)

def LtoS(ls):
	return ''.join([chr(i + 97) for i in ls])

def RA():
	return map(int, open(0).read().split())

def RLI(n=8, a=1, b=10):
	return [random.randint(a, b) for i in range(n)]

def RI(a=1, b=10):
	return random.randint(a, b)

def Rtest(T):
	(case, err) = (0, 0)
	for i in range(T):
		inp = INP()
		(a1, ls) = naive(*inp)
		a2 = solve(*inp)
		if a1 != a2:
			print((a1, a2), inp)
			err += 1
		case += 1
	print('Tested', case, 'case with', err, 'errors')

def GI(V, E, ls=None, Directed=False, index=1):
	org_inp = []
	g = [[] for i in range(V)]
	FromStdin = True if ls == None else False
	for i in range(E):
		if FromStdin:
			inp = LI()
			org_inp.append(inp)
		else:
			inp = ls[i]
		if len(inp) == 2:
			(a, b) = inp
			c = 1
		else:
			(a, b, c) = inp
		if index == 1:
			a -= 1
			b -= 1
		aa = (a, c)
		bb = (b, c)
		g[a].append(bb)
		if not Directed:
			g[b].append(aa)
	return (g, org_inp)

def GGI(h, w, search=None, replacement_of_found='.', mp_def={'#': 1, '.': 0}, boundary=1):
	mp = [boundary] * (w + 2)
	found = {}
	for i in R(h):
		s = input()
		for char in search:
			if char in s:
				found[char] = (i + 1) * (w + 2) + s.index(char) + 1
				mp_def[char] = mp_def[replacement_of_found]
		mp += [boundary] + [mp_def[j] for j in s] + [boundary]
	mp += [boundary] * (w + 2)
	return (h + 2, w + 2, mp, found)

def TI(n):
	return GI(n, n - 1)

def accum(ls):
	rt = [0]
	for i in ls:
		rt += [rt[-1] + i]
	return rt

def bit_combination(n, base=2):
	rt = []
	for tb in R(base ** n):
		s = [tb // base ** bt % base for bt in R(n)]
		rt += [s]
	return rt

def gcd(x, y):
	if y == 0:
		return x
	if x % y == 0:
		return y
	while x % y != 0:
		(x, y) = (y, x % y)
	return y

def YN(x):
	print(['NO', 'YES'][x])

def Yn(x):
	print(['No', 'Yes'][x])

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)
mo = 10 ** 9 + 7
inf = float('inf')
FourNb = [(-1, 0), (1, 0), (0, 1), (0, -1)]
EightNb = [(-1, 0), (1, 0), (0, 1), (0, -1), (1, 1), (-1, -1), (1, -1), (-1, 1)]
compas = dict(zip('WENS', FourNb))
cursol = dict(zip('LRUD', FourNb))
l_alp = string.ascii_lowercase
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
input = lambda : sys.stdin.readline().rstrip()
import sys, bisect, string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, groupby
rep = range

def Golf():
	(n, *t) = map(int, open(0).read().split())

def I():
	return int(input())

def S_():
	return input()

def IS():
	return input().split()

def LS():
	return [i for i in input().split()]

def MI():
	return map(int, input().split())

def LI():
	return [int(i) for i in input().split()]

def LI_():
	return [int(i) - 1 for i in input().split()]

def NI(n):
	return [int(input()) for i in range(n)]

def NI_(n):
	return [int(input()) - 1 for i in range(n)]

def StoLI():
	return [ord(i) - 97 for i in input()]

def ItoS(n):
	return chr(n + 97)

def LtoS(ls):
	return ''.join([chr(i + 97) for i in ls])

def RA():
	return map(int, open(0).read().split())

def GI(V, E, ls=None, Directed=False, index=1):
	org_inp = []
	g = [[] for i in range(V)]
	FromStdin = True if ls == None else False
	for i in range(E):
		if FromStdin:
			inp = LI()
			org_inp.append(inp)
		else:
			inp = ls[i]
		if len(inp) == 2:
			(a, b) = inp
			c = 1
		else:
			(a, b, c) = inp
		if index == 1:
			a -= 1
			b -= 1
		aa = (a, c)
		bb = (b, c)
		g[a].append(bb)
		if not Directed:
			g[b].append(aa)
	return (g, org_inp)

def GGI(h, w, search=None, replacement_of_found='.', mp_def={'#': 1, '.': 0}, boundary=1):
	mp = [boundary] * (w + 2)
	found = {}
	for i in range(h):
		s = input()
		for char in search:
			if char in s:
				found[char] = (i + 1) * (w + 2) + s.index(char) + 1
				mp_def[char] = mp_def[replacement_of_found]
		mp += [boundary] + [mp_def[j] for j in s] + [boundary]
	mp += [boundary] * (w + 2)
	return (h + 2, w + 2, mp, found)

def TI(n):
	return GI(n, n - 1)

def accum(ls):
	rt = [0]
	for i in ls:
		rt += [rt[-1] + i]
	return rt

def bit_combination(n, base=2):
	rt = []
	for tb in range(base ** n):
		s = [tb // base ** bt % base for bt in range(n)]
		rt += [s]
	return rt

def gcd(x, y):
	if y == 0:
		return x
	if x % y == 0:
		return y
	while x % y != 0:
		(x, y) = (y, x % y)
	return y

def YN(x):
	print(['NO', 'YES'][x])

def Yn(x):
	print(['No', 'Yes'][x])

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)
mo = 10 ** 9 + 7
inf = float('inf')
FourNb = [(-1, 0), (1, 0), (0, 1), (0, -1)]
EightNb = [(-1, 0), (1, 0), (0, 1), (0, -1), (1, 1), (-1, -1), (1, -1), (-1, 1)]
compas = dict(zip('WENS', FourNb))
cursol = dict(zip('LRUD', FourNb))
l_alp = string.ascii_lowercase
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline

class Tree:

	def __init__(self, inp_size=None, ls=None, init=True, index=1):
		self.LCA_init_stat = False
		self.ETtable = []
		if init:
			if ls == None:
				self.stdin(inp_size, index=index)
			else:
				self.node_size = len(ls) + 1
				(self.edges, _) = GI(self.node_size, self.node_size - 1, ls, index=index)
		return

	def stdin(self, inp_size=None, index=1):
		if inp_size == None:
			self.node_size = int(input())
		else:
			self.node_size = inp_size
		(self.edges, _) = GI(self.node_size, self.node_size - 1, index=index)
		return

	def listin(self, ls, index=0):
		self.node_size = len(ls) + 1
		(self.edges, _) = GI(self.node_size, self.node_size - 1, ls, index=index)
		return

	def dfs(self, x, func=lambda pr, prv, nx, dist: prv + dist, root_v=0):
		q = deque([x])
		v = [None] * self.node_size
		v[x] = root_v
		while q:
			c = q.pop()
			for (nb, d) in self.edges[c]:
				if v[nb] == None:
					q.append(nb)
					v[nb] = func(c, v[c], nb, d)
		return v

	def bfs(self, x, func=lambda pr, prv, nx, dist: prv + dist, root_v=0):
		q = deque([x])
		v = [None] * self.node_size
		v[x] = root_v
		while q:
			c = q.popleft()
			for (nb, d) in self.edges[c]:
				if v[nb] == None:
					q.append(nb)
					v[nb] = func(c, v[c], nb, d)
		return v

	def parent(self, x):
		return self.dfs(0, func=lambda pr, prv, nx, dist: pr, root_v=-1)

	def topological_sort(self, x):
		tps = []
		q = deque([x])
		v = [None] * self.node_size
		v[x] = 0
		while q:
			c = q.popleft()
			tps.append(c)
			for (nb, d) in self.edges[c]:
				if v[nb] == None:
					q.append(nb)
					v[nb] = 0
		return tps

	def EulerTour(self, x):
		q = deque()
		q.append(x)
		self.depth = [None] * self.node_size
		self.depth[x] = 0
		self.ETtable = []
		self.ETdepth = []
		self.ETin = [-1] * self.node_size
		self.ETout = [-1] * self.node_size
		cnt = 0
		while q:
			c = q.pop()
			if c < 0:
				ce = ~c
			else:
				ce = c
				for (nb, d) in self.edges[ce]:
					if self.depth[nb] == None:
						q.append(~ce)
						q.append(nb)
						self.depth[nb] = self.depth[ce] + 1
			self.ETtable.append(ce)
			self.ETdepth.append(self.depth[ce])
			if self.ETin[ce] == -1:
				self.ETin[ce] = cnt
			else:
				self.ETout[ce] = cnt
			cnt += 1
		return

	def doubling_LCA(self, root, x, y):
		if self.LCA_init_stat == False:
			self.depth = [None] * self.node_size
			self.depth = self.bfs(0, func=lambda pr, prv, nxt, dist: prv + 1)
			self.par = self.bfs(0, func=lambda pr, prv, nxt, dist: pr)
			self.db = [self.par]
			for i in range(self.node_size.bit_length()):
				self.db += [[self.db[-1][self.db[-1][i]] for i in range(self.node_size)]]
			self.LCA_init_stat = True
		dx = self.depth[x]
		dy = self.depth[y]
		if dx > dy:
			(dx, dy) = (dy, dx)
		c = self.node_size.bit_length()
		while c > 0:
			if dx + c <= dy:
				x = self.db[c][x]
				dx += 1 << c
			c >>= 1
		if x == y:
			return x
		c = self.node_size.bit_length()
		while c > 0:
			if self.db[c][x] != self.db[c][y]:
				x = self.db[c][x]
				y = self.db[c][y]
			c >>= 1
		return self.par[x]

	def LCA_init(self, root):
		self.EulerTour(root)
		self.st = SparseTable(self.ETdepth, init_func=min, init_idl=inf)
		self.LCA_init_stat = True
		return

	def LCA(self, root, x, y):
		if self.LCA_init_stat == False:
			self.LCA_init(root)
		(xin, xout) = (self.ETin[x], self.ETout[x])
		(yin, yout) = (self.ETin[y], self.ETout[y])
		a = min(xin, yin)
		b = max(xout, yout, xin, yin)
		id_of_min_dep_in_et = self.st.query_id(a, b + 1)
		return self.ETtable[id_of_min_dep_in_et]

	def __str__(self):
		return str(self.edges)

	def show(self):
		if all([all([d == 1 for (nd, d) in e]) for e in self.edges]):
			print([[nd for (nd, d) in e] for e in self.edges])
		else:
			print(self)

	def dfs2(self, x, func=lambda pr, prv, nx, dist: prv + dist, root_v=0):
		q = deque([x])
		v = [None] * self.node_size
		v[x] = root_v
		dfs_tr = [x]
		while q:
			c = q.pop()
			for (nb, d) in self.edges[c]:
				if v[nb] == None:
					q.append(nb)
					v[nb] = func(c, v[c], nb, d)
					dfs_tr += (nb,)
		return (v, dfs_tr)
show_flg = False
show_flg = True
ans = 0

def dfs(x, func=lambda pr, prv, nx, dist: prv + dist, root_v=0):
	q = deque([x])
	v = [None] * len(g)
	v[x] = root_v
	while q:
		c = q.pop()
		for (nb, d) in g[c]:
			if v[nb] == None:
				q.append(nb)
				v[nb] = func(c, v[c], nb, d)
	return v
for _ in range(I()):
	k = 1
	ans = 'Yes'
	(n, sa, sb, a, b) = LI()
	sa -= 1
	sb -= 1
	(g, _) = GI(n, n - 1)
	v = dfs(sa)
	if v[sb] <= a:
		k = 0
	tmp = 0
	for i in range(n):
		if tmp < v[i]:
			tmp = v[i]
			ep = i
	v = dfs(ep)
	D = max(v)
	if a >= (D + 1) // 2:
		k = 0
	if 2 * a >= b:
		k = 0
	print(['Alice', 'Bob'][k])


diameter = 0

def dfs(u, tree, depth):
	global diameter
	length = 0
	level[u] = depth
	isCheck[u] = True
	for vertex in tree[u]:
		if isCheck[vertex] != True:
			isCheck[vertex] = True
			cur = dfs(vertex, tree, depth + 1) + 1
			diameter = max(diameter, cur + length)
			length = max(length, cur)
	return length
t = int(input())
for _ in range(t):
	(n, a, b, da, db) = map(int, input().split())
	tree = [[] for _ in range(n + 1)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		tree[u].append(v)
		tree[v].append(u)
	isCheck = [0 for _ in range(n + 1)]
	level = [0 for _ in range(n + 1)]
	diameter = 0
	dfs(a, tree, 1)
	dist = abs(level[a] - level[b])
	if dist <= da:
		print('Alice')
	elif 2 * da >= min(diameter, db):
		print('Alice')
	elif db > 2 * da:
		print('Bob')


import sys
sys.setrecursionlimit(10 ** 6 + 5)
from collections import defaultdict as dft, deque
mxn = 10 ** 9

def mp():
	return map(int, input().split())

def solve():

	def diss(u, v):
		if u == v:
			return 0
		vis[u] = 1
		m = mxn
		for lnk in dct[u]:
			if vis[lnk]:
				continue
			m = min(m, diss(lnk, v))
		return m + 1

	def dist(n, s):
		D = [-1] * (n + 5)
		Q = deque()
		Q.append(s)
		D[s] = 0
		while Q:
			f = Q.popleft()
			for t in dct[f]:
				if D[t] == -1:
					D[t] = D[f] + 1
					Q.append(t)
		return D
	(n, a, b, da, db) = map(int, input().split())
	dct = dft(list)
	for i in range(n - 1):
		(u, v) = mp()
		dct[u].append(v)
		dct[v].append(u)
	vis = [0] * (n + 5)
	d = diss(a, b)
	if d <= da:
		return True
	Da = dist(n, a)
	me = max(enumerate(Da), key=lambda x: x[1])[0]
	if max(dist(n, me)) <= 2 * da:
		return True
	if db <= 2 * da:
		return True
	return False
for _ in range(int(input())):
	if solve():
		print('Alice')
	else:
		print('Bob')


import sys
sys.setrecursionlimit(10 ** 5)

def search(tree, cur, find, was):
	was.add(cur)
	for i in tree[cur]:
		if i == find:
			return (1, True)
		elif not i in was:
			a = search(tree, i, find, was)
			if a[1]:
				return (a[0] + 1, a[1])
	return (-1, False)

def max_depth(tree, cur, was_2):
	was_2.add(cur)
	dist = 0
	dot = cur
	for i in tree[cur]:
		if not i in was_2:
			(new_dist, new_dot) = max_depth(tree, i, was_2)
			if max(new_dist, dist) == new_dist:
				dist = max(new_dist, dist)
				dot = new_dot
	return (dist + 1, dot)

def main():
	was = set()
	was_2 = set()
	(n, a, b, da, db) = map(int, input().split())
	tree = dict()
	for i in range(1, n):
		(u, v) = map(int, input().split())
		if not u in tree:
			tree[u] = set()
		if not v in tree:
			tree[v] = set()
		tree[u].add(v)
		tree[v].add(u)
	dist = search(tree, a, b, was)
	(far, dot) = max_depth(tree, a, was_2)
	was_2 = set()
	ln = max_depth(tree, dot, was_2)
	if dist[0] <= da or db <= 2 * da or ln[0] - 1 <= 2 * da:
		print('Alice')
		return
	else:
		print('Bob')
		return
t = int(input())
for i in range(t):
	main()


import os
import sys
from io import BytesIO, IOBase
import threading
from collections import defaultdict

def main():
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	graph = [[] for i in range(n)]
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		x -= 1
		y -= 1
		graph[x].append(y)
		graph[y].append(x)
	visited = [0] * n
	dist = [0] * n
	q = [b]
	visited[b] = 1
	while len(q):
		node = q.pop()
		for adj in graph[node]:
			if not visited[adj]:
				dist[adj] = dist[node] + 1
				visited[adj] = 1
				q.append(adj)
	if dist[a] > da and db > 2 * da:
		x = 0
		p = 0
		for i in range(n):
			if dist[i] > p:
				p = dist[i]
				x = i
		visited = [0] * n
		dist = [0] * n
		q = [x]
		visited[x] = 1
		while len(q):
			node = q.pop()
			for adj in graph[node]:
				if not visited[adj]:
					dist[adj] = dist[node] + 1
					visited[adj] = 1
					q.append(adj)
		if max(dist) > 2 * da:
			print('Bob')
		else:
			print('Alice')
	else:
		print('Alice')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
for i in range(int(input())):
	main()


import sys, math
import io, os
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter

def data():
	return sys.stdin.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write(' '.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
from decimal import Decimal
mod = int(1000000000.0) + 7
INF = 100000

def dfs(graph, start=0):
	n = len(graph)
	dp = [0] * n
	(visited, finished) = ([False] * n, [False] * n)
	m = 0
	ind = 0
	dp[start] = 1
	stack = [start]
	while stack:
		start = stack[-1]
		if not visited[start]:
			visited[start] = True
			for child in graph[start]:
				if not visited[child]:
					stack.append(child)
					dp[child] = dp[start] + 1
					if dp[child] > m:
						m = dp[child]
						ind = child
		else:
			stack.pop()
			finished[start] = True
	return (dp[a - 1] - 1, m, ind)
for t in range(int(data())):
	(n, a, b, da, db) = mdata()
	graph = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = mdata()
		graph[u - 1].append(v - 1)
		graph[v - 1].append(u - 1)
	if 2 * da >= db:
		out('Alice')
		continue
	(dis, m, ind) = dfs(graph, b - 1)
	(dis1, m, ind) = dfs(graph, ind)
	if m > 2 * da + 1 and dis > da:
		out('Bob')
		continue
	out('Alice')


import sys
import math
T = int(sys.stdin.readline().strip())
for _ in range(T):
	(n, a, b, da, db) = map(int, sys.stdin.readline().strip().split())
	a -= 1
	b -= 1
	edges = []
	for _ in range(n - 1):
		edges.append(tuple(map(lambda v: int(v) - 1, sys.stdin.readline().strip().split())))
	if a == b:
		print('Alice')
		continue
	graph = [[] for _ in range(n)]
	for (frm, to) in edges:
		graph[frm].append(to)
		graph[to].append(frm)
	visited = [False for _ in range(n)]

	def dist_between(cur):
		visited[cur] = True
		if cur == b:
			return 0
		res = n + 1
		for nxt in graph[cur]:
			if visited[nxt]:
				continue
			res = min(res, 1 + dist_between(nxt))
		return res
	if dist_between(a) <= da:
		print('Alice')
		continue

	def find_farthest(i, dist):
		res = dist
		node = i
		visited[i] = True
		for nxt in graph[i]:
			if visited[nxt]:
				continue
			(d, n) = find_farthest(nxt, dist + 1)
			if d > res:
				res = d
				node = n
		return (res, node)
	visited = [False for _ in range(n)]
	(_, edge_node) = find_farthest(0, 0)
	visited = [False for _ in range(n)]
	(diameter, _) = find_farthest(edge_node, 0)
	da = min(da, diameter)
	db = min(db, diameter)
	if da < math.ceil(db / 2):
		print('Bob')
	else:
		print('Alice')


import sys
ii = lambda : sys.stdin.readline().strip()
idata = lambda : [int(x) for x in ii().split()]

def bfs(graph, start_ver):
	visited = set()
	queue = [[start_ver, 0]]
	visited.add(start_ver)
	(ans_way_length, ans_ver) = (0, 1)
	while queue:
		ver = queue[0]
		queue = queue[1:]
		for new_ver in graph[ver[0]]:
			if new_ver not in visited:
				visited.add(new_ver)
				queue += [[new_ver, ver[1] + 1]]
				if ans_way_length < ver[1] + 1:
					(ans_ver, ans_way_length) = (new_ver, ver[1] + 1)
	return (ans_ver, ans_way_length)

def dfs(graph, ver):
	visited = set()
	depth = [0] * (len(graph) + 1)
	level = [ver]
	num_of_level = 0
	while level:
		new_level = []
		for v in level:
			depth[v] = num_of_level
			visited.add(v)
			for v1 in graph[v]:
				if v1 not in visited:
					new_level += [v1]
		level = new_level[:]
		num_of_level += 1
	return depth

def solve():
	(n, a, b, da, db) = idata()
	graph = {}
	for i in range(n - 1):
		(v, u) = idata()
		if not v in graph:
			graph[v] = [u]
		else:
			graph[v] += [u]
		if not u in graph:
			graph[u] = [v]
		else:
			graph[u] += [v]
	q = dfs(graph, a)[b]
	if q <= da:
		print('Alice')
		return
	(x, y) = bfs(graph, a)
	(x, y) = bfs(graph, x)
	if y <= 2 * da:
		print('Alice')
		return
	if db <= 2 * da:
		print('Alice')
		return
	print('Bob')
	return
for t in range(int(ii())):
	solve()


from sys import stdin

class Input:

	def readline(self):
		return stdin.readline().strip()

	def read_int(self):
		return int(self.readline())

	def read_list(self):
		return self.readline().split()

	def test_cases(self):
		cases = self.read_int()
		for case in range(cases):
			yield self

class Problem:

	def __init__(self, input):
		(self.n, self.a, self.b, self.da, self.db) = list(map(int, input.read_list()))
		self.a -= 1
		self.b -= 1
		self.g = [[] for i in range(self.n)]
		for i in range(self.n - 1):
			(u, v) = list(map(int, input.read_list()))
			self.g[u - 1].append(v - 1)
			self.g[v - 1].append(u - 1)

	def dfs(self, v, dist=0):
		self.d[v] = dist
		for u in self.g[v]:
			if self.d[u] == None:
				self.dfs(u, dist + 1)

	def solution(self):
		if self.da * 2 >= self.db:
			return 'Alice'
		self.d = [None for i in range(self.n)]
		self.dfs(self.a)
		if self.d[self.b] <= self.da:
			return 'Alice'
		f = self.d.index(max(self.d))
		self.d = [None for i in range(self.n)]
		self.dfs(f)
		d = max(self.d)
		if self.da * 2 >= d:
			return 'Alice'
		return 'Bob'

	def answer(self):
		print(self.solution())
for case_input in Input().test_cases():
	Problem(case_input).answer()


from collections import deque
import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
ans = ['Bob'] * T
for t in range(T):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	edge = [[] for _ in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		edge[u - 1].append(v - 1)
		edge[v - 1].append(u - 1)
	visited = [False] * n
	d = deque()
	visited[a] = True
	d.append((a, 0))
	while len(d) > 0:
		(v, cnt) = d.popleft()
		for w in edge[v]:
			if w == b:
				cnt += 1
				break
			if visited[w] == False:
				visited[w] = True
				d.append((w, cnt + 1))
		else:
			continue
		break
	if cnt <= da:
		ans[t] = 'Alice'
	visited = [False] * n
	d = deque()
	visited[0] = True
	d.append(0)
	while len(d) > 0:
		v = d.popleft()
		for w in edge[v]:
			if visited[w] == False:
				visited[w] = True
				d.append(w)
	visited = [False] * n
	d = deque()
	visited[v] = True
	d.append((v, 0))
	while len(d) > 0:
		(v, cnt) = d.popleft()
		for w in edge[v]:
			if visited[w] == False:
				visited[w] = True
				d.append((w, cnt + 1))
	tyokkei = cnt
	if min(tyokkei, db) <= da * 2:
		ans[t] = 'Alice'
print(*ans, sep='\n')


from sys import stdin
from collections import deque

def NC_Dij(lis, start):
	ret = [float('inf')] * len(lis)
	ret[start] = 0
	q = deque([start])
	plis = [i for i in range(len(lis))]
	while len(q) > 0:
		now = q.popleft()
		for nex in lis[now]:
			if ret[nex] > ret[now] + 1:
				ret[nex] = ret[now] + 1
				plis[nex] = now
				q.append(nex)
	return (ret, plis)
tt = int(stdin.readline())
for loop in range(tt):
	(n, a, b, da, db) = list(map(int, stdin.readline().split()))
	N = n
	a -= 1
	b -= 1
	lis = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = list(map(int, stdin.readline().split()))
		u -= 1
		v -= 1
		lis[u].append(v)
		lis[v].append(u)
	if 2 * da >= db:
		print('Alice')
		continue
	(fa, tmp) = NC_Dij(lis, a)
	if fa[b] <= da:
		print('Alice')
		continue
	mv = 0
	for i in range(N):
		if fa[i] > fa[mv]:
			mv = i
	(fv, tmp) = NC_Dij(lis, mv)
	if max(fv) <= 2 * da:
		print('Alice')
	else:
		print('Bob')


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	adjacencyList = []
	for _ in range(n):
		adjacencyList.append([])
	for _ in range(n - 1):
		(p, q) = map(int, input().split())
		adjacencyList[p - 1].append(q - 1)
		adjacencyList[q - 1].append(p - 1)
	if da * 2 >= db:
		print('Alice')
		continue
	bfsList = []
	distance = [-1] * n
	bfsIndex = 0
	bfsList.append((a - 1, 0))
	distance[a - 1] = 0
	while len(bfsList) > bfsIndex:
		(curVertex, curDist) = bfsList[bfsIndex]
		bfsIndex += 1
		for elem in adjacencyList[curVertex]:
			if distance[elem] == -1:
				distance[elem] = curDist + 1
				bfsList.append((elem, curDist + 1))
	if distance[b - 1] <= da:
		print('Alice')
		continue
	lastVertex = bfsList[-1][0]
	bfsList = [(lastVertex, 0)]
	distance = [-1] * n
	distance[lastVertex] = 0
	bfsIndex = 0
	while len(bfsList) > bfsIndex:
		(curVertex, curDist) = bfsList[bfsIndex]
		bfsIndex += 1
		for elem in adjacencyList[curVertex]:
			if distance[elem] == -1:
				distance[elem] = curDist + 1
				bfsList.append((elem, curDist + 1))
	diameter = bfsList[-1][1]
	if diameter <= 2 * da:
		print('Alice')
		continue
	else:
		print('Bob')
		continue


import sys
import heapq, functools, collections
import math, random
from collections import Counter, defaultdict

def solve(grid, n, a, b, x, y):
	grid = [(u - 1, v - 1) for (u, v) in grid]
	(a, b) = (a - 1, b - 1)
	console('----- solving ------')
	if 2 * x >= y:
		console('cannot escape evenutally')
		return 'Alice'
	d = defaultdict(list)
	for (u, v) in grid:
		d[u].append(v)
		d[v].append(u)
	visited = [-1 for _ in range(n)]
	visited[a] = 0
	stack = [(a, 0)]
	while stack:
		(cur, dist) = stack.pop()
		for nex in d[cur]:
			if visited[nex] != -1:
				continue
			visited[nex] = dist + 1
			stack.append((nex, dist + 1))
	console(visited)
	if visited[b] <= x:
		console('catch at first step')
		return 'Alice'
	end = visited.index(max(visited))
	visited = [-1 for _ in range(n)]
	visited[end] = 0
	stack = [(end, 0)]
	while stack:
		(cur, dist) = stack.pop()
		for nex in d[cur]:
			if visited[nex] != -1:
				continue
			visited[nex] = dist + 1
			stack.append((nex, dist + 1))
	console(visited)
	if max(visited) > 2 * x:
		console('big enough')
		return 'Bob'
	console('not big enough')
	return 'Alice'

def console(*args):
	return
inp = sys.stdin.readlines()
currow = 0
for case_num in range(int(inp[currow])):
	currow = currow + 1
	(nrows, a, b, x, y) = list(map(int, inp[currow].split()))
	grid = []
	for _ in range(nrows - 1):
		currow = currow + 1
		grid.append(list(map(int, inp[currow].split())))
	res = solve(grid, nrows, a, b, x, y)
	print(res)


import sys
input = sys.stdin.buffer.readline
T = int(input())

def f(x, y):
	dg = 10 ** 6
	if x == 0:
		return y
	elif x < dg:
		if x > y:
			return y * dg + x
		else:
			return x * dg + y
	else:
		(xs, xf) = divmod(x, dg)
		if xs < y:
			xs = y
		else:
			return x
		if xf < xs:
			return xf * dg + xs
		else:
			return xs * dg + xf
for testcase in range(T):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	edge = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		edge[u - 1].append(v - 1)
		edge[v - 1].append(u - 1)
	pa = [-1] * n
	pa[a] = 0
	tank = [a]
	order = []
	par = [-1] * n
	while tank:
		now = tank.pop()
		order.append(now)
		for e in edge[now]:
			if pa[e] == -1:
				pa[e] = pa[now] + 1
				tank.append(e)
				par[e] = now
	pb = [-1] * n
	pb[b] = 0
	tank = [b]
	while tank:
		now = tank.pop()
		for e in edge[now]:
			if pb[e] == -1:
				pb[e] = pb[now] + 1
				tank.append(e)
	if 2 * da + 1 > db or pa[b] <= da:
		print('Alice')
	else:
		depth = [0] * n
		dg = 10 ** 6
		for e in order[::-1]:
			if par[e] == -1:
				continue
			depth[par[e]] = f(depth[par[e]], depth[e] % dg + 1)
		flag = False
		for e in order:
			(se, fi) = divmod(depth[e], dg)
			if fi >= 2 * da + 1:
				flag = True
				break
			for nxt in edge[e]:
				if par[e] == nxt:
					continue
				(nse, nfi) = divmod(depth[nxt], dg)
				if nfi == fi - 1:
					depth[nxt] = f(depth[nxt], se + 1)
				else:
					depth[nxt] = f(depth[nxt], fi + 1)
		if flag:
			print('Bob')
		else:
			print('Alice')


from collections import deque

def dfs(neighbours, x, n):
	parents = [None for i in range(n)]
	dq = deque()
	dq.append(x)
	parents[x] = 0
	while len(dq) != 0:
		ret = dq.popleft()
		for i in neighbours[ret]:
			if parents[i] == None:
				parents[i] = parents[ret] + 1
				dq.append(i)
	return parents
ans = []
test_cases = int(input())
for i in range(test_cases):
	(n, a, b, da, db) = [int(j) for j in input().split()]
	a = a - 1
	b = b - 1
	neighbours = [[] for j in range(n)]
	for i in range(n - 1):
		(x, y) = [int(node) - 1 for node in input().split()]
		neighbours[x].append(y)
		neighbours[y].append(x)
	distances = dfs(neighbours, a, n)
	distw = max(distances)
	w = distances.index(distw)
	diam = max(dfs(neighbours, w, n))
	if distances[b] <= da:
		ans.append('Alice')
	elif diam <= 2 * da:
		ans.append('Alice')
	elif db <= 2 * da:
		ans.append('Alice')
	else:
		ans.append('Bob')
for i in range(test_cases):
	print(ans[i])


import sys
input = sys.stdin.readline
from collections import deque

class Graph(object):

	def __init__(self, n, d):
		self.n = n
		self.graph = [[] for i in range(n)]
		self.parent = [-1 for i in range(n)]
		self.directed = d

	def addEdge(self, x, y):
		self.graph[x].append(y)
		if not self.directed:
			self.graph[y].append(x)

	def bfs(self, root):
		queue = [root]
		queue = deque(queue)
		vis = [0] * self.n
		dist = [0] * n
		while len(queue) != 0:
			element = queue.popleft()
			vis[element] = 1
			for i in self.graph[element]:
				if vis[i] == 0:
					queue.append(i)
					self.parent[i] = element
					dist[i] = dist[element] + 1
					vis[i] = 1
		return dist.index(max(dist))

	def dfs(self, root, ans):
		stack = [root]
		vis = [0] * self.n
		stack2 = []
		dist = [0] * n
		while len(stack) != 0:
			element = stack.pop()
			if vis[element]:
				continue
			vis[element] = 1
			stack2.append(element)
			for i in self.graph[element]:
				if vis[i] == 0:
					self.parent[i] = element
					stack.append(i)
		while len(stack2) != 0:
			element = stack2.pop()
			m = {}
			maxx = 0
			for i in self.graph[element]:
				if i != self.parent[element]:
					m[i] = dist[i]
					maxx = max(maxx, dist[i])
			ans[element] = m
			if ans[element]:
				dist[element] = maxx + 1
			else:
				dist[element] = 0
		return (ans, dist)

	def shortestpath(self, source, dest):
		self.bfs(source)
		path = [dest]
		while self.parent[path[-1]] != -1:
			path.append(parent[path[-1]])
		return path[::-1]

	def detect_cycle(self):
		indeg = [0] * self.n
		for i in range(self.n):
			for j in self.graph[i]:
				indeg[j] += 1
		q = deque()
		vis = 0
		for i in range(self.n):
			if indeg[i] == 0:
				q.append(i)
		while len(q) != 0:
			e = q.popleft()
			vis += 1
			for i in self.graph[e]:
				indeg[i] -= 1
				if indeg[i] == 0:
					q.append(i)
		if vis != self.n:
			return True
		return False

	def reroot(self, root, ans):
		stack = [root]
		vis = [0] * n
		while len(stack) != 0:
			e = stack[-1]
			if vis[e]:
				stack.pop()
				continue
			vis[e] = 1
			for i in graph[e]:
				if not vis[e]:
					stack.append(i)
			if self.parent[e] == -1:
				continue

	def calc(self, root):
		add = 0
		done = {root: 0}
		while True:
			v = ans[root].values()
			v.append(add)
			v.sort()
			for i in self.graph[root]:
				if ans[root][i] == v[-1]:
					root = i
					add = v[-2]

	def bfs2(self, root, arr):
		queue = [root]
		queue = deque(queue)
		vis = [0] * self.n
		while len(queue) != 0:
			element = queue.popleft()
			vis[element] = 1
			for i in self.graph[element]:
				if vis[i] == 0:
					queue.append(i)
					self.parent[i] = element
					arr[i] = arr[element] + 1
					vis[i] = 1
		return arr
for nt in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	g = Graph(n, False)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		g.addEdge(u - 1, v - 1)
	if da >= (db - 1) // 2 + 1:
		print('Alice')
		continue
	d = [0] * n
	d = g.bfs2(a - 1, d)
	if d[b - 1] <= da:
		print('Alice')
		continue
	e1 = g.bfs(a - 1)
	e2 = g.bfs(e1)
	d1 = [0] * n
	d2 = [0] * n
	d1 = g.bfs2(e1, d1)
	d2 = g.bfs2(e2, d2)
	f = []
	for i in range(n):
		f.append(max(d1[i], d2[i]))
	if min(f) <= da:
		print('Alice')
	else:
		print('Bob')


from heapq import heappush, heappop
from collections import defaultdict, Counter, deque
import threading
import sys
import bisect
input = sys.stdin.readline

def ri():
	return int(input())

def rs():
	return input()

def rl():
	return list(map(int, input().split()))

def rls():
	return list(input().split())
threading.stack_size(10 ** 8)
sys.setrecursionlimit(10 ** 6)

def main():
	for _ in range(ri()):
		(n, a, b, da, db) = rl()
		g = defaultdict(list)
		for e in range(n - 1):
			(u, v) = rl()
			g[u].append(v)
			g[v].append(u)
		dis = [0] * (n + 1)
		dia = [0]
		dis[a] = 0

		def dfs(cn, p):
			mx = 0
			for nn in g[cn]:
				if nn != p:
					dis[nn] = dis[cn] + 1
					cur = 1 + dfs(nn, cn)
					dia[0] = max(dia[0], cur + mx)
					mx = max(mx, cur)
			return mx
		dfs(a, -1)
		if dis[b] <= da:
			pos = 1
		elif 2 * da >= dia[0]:
			pos = 1
		elif db > 2 * da:
			pos = 0
		elif db <= 2 * da:
			pos = 1
		print(['Bob', 'Alice'][pos])
	pass
threading.Thread(target=main).start()


from collections import deque
import sys
input = sys.stdin.buffer.readline

def main():
	(n, a, b, da, db) = map(int, input().split())
	edges = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		edges[u].append(v)
		edges[v].append(u)
	if da * 2 >= db:
		print('Alice')
		return
	a -= 1
	b -= 1
	queue = deque()
	queue.append(a)
	queue.append(0)
	check = [False for _ in range(n)]
	check[a] = True
	ab = -1
	while queue:
		pos = queue.popleft()
		d = queue.popleft() + 1
		for n_pos in edges[pos]:
			if check[n_pos]:
				continue
			check[n_pos] = True
			if n_pos == b:
				ab = d
			queue.append(n_pos)
			queue.append(d)
	if ab <= da:
		print('Alice')
		return
	queue = deque()
	queue.append(pos)
	queue.append(0)
	check = [False for _ in range(n)]
	check[pos] = True
	while queue:
		pos = queue.popleft()
		d = queue.popleft() + 1
		for n_pos in edges[pos]:
			if check[n_pos]:
				continue
			check[n_pos] = True
			queue.append(n_pos)
			queue.append(d)
	d -= 1
	if d <= da * 2:
		print('Alice')
	else:
		print('Bob')
t = int(input())
for _ in range(t):
	main()


import sys
input = sys.stdin.readline
from collections import deque
t = int(input())
for _ in range(t):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	adj = [[] for i in range(n)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		adj[u - 1].append(v - 1)
		adj[v - 1].append(u - 1)
	if db <= 2 * da:
		print('Alice')
	else:
		works = True
		dist = [-1] * n
		q = deque()
		q.append(a)
		dist[a] = 0
		while q:
			v = q.popleft()
			for u in adj[v]:
				if dist[u] == -1:
					dist[u] = dist[v] + 1
					q.append(u)
		if dist[b] <= da:
			works = False
		last = v
		dist = [-1] * n
		q = deque()
		q.append(last)
		dist[last] = 0
		while q:
			v = q.popleft()
			for u in adj[v]:
				if dist[u] == -1:
					dist[u] = dist[v] + 1
					q.append(u)
		lorg = max(dist)
		if lorg >= 2 * da + 1 and works:
			print('Bob')
		else:
			print('Alice')


from sys import stdin

def inp():
	return stdin.buffer.readline().rstrip().decode('utf8')

def itg():
	return int(stdin.buffer.readline())

def mpint():
	return map(int, stdin.buffer.readline().split())
from copy import deepcopy

def to_tree(graph, root=0):
	graph[:] = map(set, graph)
	stack = [[root]]
	while stack:
		if not stack[-1]:
			del stack[-1]
			continue
		vertex = stack[-1].pop()
		for e in graph[vertex]:
			graph[e].remove(vertex)
		stack.append(list(graph[vertex]))
	graph[:] = map(list, graph)

def to_graph(tree, root=0):
	tree[:] = map(set, tree)
	for (node1, node_set) in enumerate(deepcopy(tree)):
		for node2 in node_set:
			tree[node2].add(node1)
	tree[:] = map(list, tree)

def tree_distance(tree, u, v):
	if u == v:
		return 0
	graph = deepcopy(tree)
	to_graph(graph)
	graph[:] = map(set, graph)
	curr = {u}
	step = 1
	while True:
		nxt = set()
		for node in curr:
			if v in graph[node]:
				return step
			nxt |= graph[node]
		curr = nxt
		step += 1

def tree_bfs(tree, start=0, flat=False):
	stack = [start]
	result = []
	while stack:
		new_stack = []
		if flat:
			result.extend(stack)
		else:
			result.append(stack)
		for node in stack:
			new_stack.extend(tree[node])
		stack = new_stack
	return result

def tree_farthest(tree):
	node1 = tree_bfs(tree, flat=True)[-1]
	to_graph(tree)
	to_tree(tree, node1)
	bfs_data = tree_bfs(tree, node1)
	node2 = bfs_data[-1][-1]
	return (node1, node2, len(bfs_data))

def solve():
	(n, a, b, da, db) = mpint()
	a -= 1
	b -= 1
	tree = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = mpint()
		u -= 1
		v -= 1
		tree[u].append(v)
		tree[v].append(u)
	if db - da < 2:
		return True
	to_tree(tree)
	if tree_distance(tree, a, b) <= da:
		return True
	longest = tree_farthest(tree)[2]
	dis = longest >> 1
	return dis <= da or db < da * 2 + 1
for __ in range(itg()):
	print('Alice' if solve() else 'Bob')


t = int(input())
depth = [0 for _ in range(200050)]
for _ in range(t):
	(n, a, b, da, db) = list(map(int, input().split(' ')))
	edges = [[] for _ in range(n + 2)]
	for i in range(n - 1):
		(u, v) = list(map(int, input().split(' ')))
		edges[u].append(v)
		edges[v].append(u)
	diameter = 0
	depth[a] = 0

	def dfs(u, f):
		global diameter
		l = 0
		for v in edges[u]:
			if v == f:
				continue
			depth[v] = depth[u] + 1
			cur = 1 + dfs(v, u)
			diameter = max(diameter, cur + l)
			l = max(l, cur)
		return l
	dfs(a, -1)
	if depth[b] <= da or da * 2 >= diameter or da * 2 >= db:
		print('Alice')
	else:
		print('Bob')


from types import GeneratorType

def bootstrap(f, stack=[]):

	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to
	return wrappedfunc
import sys
input = sys.stdin.buffer.readline

@bootstrap
def getAtoBDist(node, p, d):
	if node == b:
		yield d
	for nex in adj[node]:
		if nex != p:
			d2 = (yield getAtoBDist(nex, node, d + 1))
			if d2 != -1:
				yield d2
	yield (-1)

@bootstrap
def getTreeWidth(node, p):
	childLeafDistances = [0, 0]
	cld = childLeafDistances
	for nex in adj[node]:
		if nex != p:
			cld.append((yield getTreeWidth(nex, node)))
	cld.sort(reverse=True)
	treeWidth[0] = max(treeWidth[0], cld[0] + cld[1])
	yield (max(cld) + 1)
t = int(input())
for _ in range(t):
	(n, a, b, da, db) = [int(x) for x in input().split()]
	adj = [[] for _a in range(n + 1)]
	for _b in range(n - 1):
		(u, v) = [int(x) for x in input().split()]
		adj[u].append(v)
		adj[v].append(u)
	gap = getAtoBDist(a, 0, 0)
	treeWidth = [0]
	getTreeWidth(1, 0)
	if gap > da and db > 2 * da and (treeWidth[0] > 2 * da):
		print('Bob')
	else:
		print('Alice')


import os
import heapq
import sys, threading
import math
import bisect
import operator
from collections import defaultdict, deque
sys.setrecursionlimit(10 ** 5)
from io import BytesIO, IOBase

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def power(x, p, m):
	res = 1
	while p:
		if p & 1:
			res = res * x % m
		x = x * x % m
		p >>= 1
	return res

def inar():
	return [int(k) for k in input().split()]

def lcm(num1, num2):
	return num1 * num2 // gcd(num1, num2)

def bfs(adj, n, start):
	lis = [-1] * n
	qu = deque()
	qu.append(start)
	lis[start] = 0
	while qu:
		el = qu.popleft()
		for child in adj[el]:
			if lis[child] == -1:
				lis[child] = lis[el] + 1
				qu.append(child)
	return lis

def main():
	t = int(input())
	for _ in range(t):
		(n, a, b, da, db) = inar()
		adj = defaultdict(list)
		a -= 1
		b -= 1
		for i in range(n - 1):
			(u, v) = inar()
			adj[u - 1].append(v - 1)
			adj[v - 1].append(u - 1)
		take = bfs(adj, n, a)
		s = max(enumerate(take), key=lambda x: x[1])[0]
		another = bfs(adj, n, s)
		if take[b] <= da or db <= 2 * da or max(another) <= 2 * da:
			print('Alice')
		else:
			print('Bob')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import collections
import sys
(*data,) = map(int, sys.stdin.read().split()[::-1])

def inp():
	return int(data.pop())
UNDEF = -1

def bfs(g, v):
	distances = [UNDEF] * len(g)
	q = collections.deque()
	q.append(v)
	distances[v] = 0
	while q:
		v = q.popleft()
		for w in g[v]:
			if distances[w] == UNDEF:
				distances[w] = distances[v] + 1
				q.append(w)
	return distances

def diameter(g):
	distances = bfs(g, 0)
	best_i = 0
	for i in range(len(g)):
		if distances[i] > distances[best_i]:
			best_i = i
	distances = bfs(g, best_i)
	return max(distances)

def solve(g, a, b, da, db):
	if 2 * da >= db:
		return True
	distances = bfs(g, a)
	if distances[b] <= da:
		return True
	diam = diameter(g)
	if 2 * da >= diam:
		return True
	if da < db:
		return False
	return False
	raise RuntimeError('')
for _ in range(int(inp())):
	(n, a, b, da, db) = (inp(), inp(), inp(), inp(), inp())
	a -= 1
	b -= 1
	g = [[] for _ in range(n)]
	for _ in range(n - 1):
		(src, dst) = (inp(), inp())
		src -= 1
		dst -= 1
		g[src].append(dst)
		g[dst].append(src)
	print('Alice' if solve(g, a, b, da, db) else 'Bob')


import os, sys
from io import IOBase, BytesIO
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.getvalue())
			(self.truncate(0), self.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			self.write = lambda s: self.buffer.write(s.encode('ascii'))
			self.read = lambda : self.buffer.read().decode('ascii')
			self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import sys

class ostream:

	def __lshift__(self, a):
		sys.stdout.write(str(a))
		return self
cout = ostream()
endl = '\n'

def dfs(i):
	q = [i]
	pa = [-1 for i in range(n)]
	de = [0 for i in range(n)]
	while q:
		x = q.pop()
		for y in tr[x]:
			if y == pa[x]:
				continue
			pa[y] = x
			de[y] = de[x] + 1
			q.append(y)
	return de
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	tr = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		tr[u].append(v)
		tr[v].append(u)
	bbb = dfs(a)
	dist = bbb[b]
	ci = bbb.index(max(bbb))
	dimr = max(dfs(ci))
	if dist <= da:
		print('Alice')
	elif 2 * da >= dimr:
		print('Alice')
	elif db <= 2 * da:
		print('Alice')
	else:
		print('Bob')


gans = []
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	u = []
	for i in range(n):
		u.append([])
	for i in range(n - 1):
		(v1, v2) = map(lambda x: int(x) - 1, input().split())
		u[v1].append(v2)
		u[v2].append(v1)
	ind = a
	q = [ind]
	q0 = 0
	INF = 100000000
	d = [INF] * n
	d[ind] = 0
	while len(q) > q0:
		v = q[q0]
		q0 += 1
		for i in u[v]:
			if d[i] > d[v] + 1:
				d[i] = d[v] + 1
				q.append(i)
	if d[b] <= da:
		gans.append('Alice')
		continue
	ind = -1
	mx = max(d)
	for i in range(n):
		if d[i] == mx:
			ind = i
			break
	q = [ind]
	q0 = 0
	d = [INF] * n
	d[ind] = 0
	while len(q) > q0:
		v = q[q0]
		q0 += 1
		for i in u[v]:
			if d[i] > d[v] + 1:
				d[i] = d[v] + 1
				q.append(i)
	D = max(d)
	if db > 2 * da and 2 * da < D:
		gans.append('Bob')
	else:
		gans.append('Alice')
print('\n'.join(gans))


mod = 1000000007
eps = 10 ** (-9)

def main():
	import sys
	from collections import deque
	input = sys.stdin.buffer.readline
	for t in range(int(input())):
		(N, a, b, da, db) = map(int, input().split())
		adj = [[] for _ in range(N + 1)]
		for _ in range(N - 1):
			(u, v) = map(int, input().split())
			adj[u].append(v)
			adj[v].append(u)
		if db < 2 * da + 1:
			print('Alice')
			continue
		que = deque()
		que.append(a)
		seen = [-1] * (N + 1)
		seen[a] = 0
		par = [0] * (N + 1)
		child = [[] for _ in range(N + 1)]
		seq = []
		while que:
			v = que.popleft()
			seq.append(v)
			for u in adj[v]:
				if seen[u] == -1:
					seen[u] = seen[v] + 1
					par[u] = v
					child[v].append(u)
					que.append(u)
		seq.reverse()
		if seen[b] <= da:
			print('Alice')
			continue
		c = seq[0]
		que2 = deque()
		que2.append(c)
		seen2 = [-1] * (N + 1)
		seen2[c] = 0
		par2 = [0] * (N + 1)
		child2 = [[] for _ in range(N + 1)]
		seq2 = []
		while que2:
			v = que2.popleft()
			seq2.append(v)
			for u in adj[v]:
				if seen2[u] == -1:
					seen2[u] = seen2[v] + 1
					par2[u] = v
					child2[v].append(u)
					que2.append(u)
		seq2.reverse()
		if seen2[seq2[0]] < da * 2 + 1:
			print('Alice')
		else:
			print('Bob')
main()


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush, heappop
import math
from collections import *
from functools import reduce, cmp_to_key, lru_cache
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
M = mod = 10 ** 9 + 7

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

def li():
	return [int(i) for i in input().rstrip().split()]

def st():
	return str(input().rstrip())[2:-1]

def val():
	return int(input().rstrip())

def li2():
	return [str(i)[2:-1] for i in input().rstrip().split()]

def li3():
	return [int(i) for i in st()]
distbetween = g = 0

def dfs(node, v=-1):
	global g, distbetween
	d = deque()
	d.append([node, 0])
	maxdist = 0
	farnode = node
	visited = {}
	while d:
		(node, dist) = d.popleft()
		visited[node] = 1
		if node == v and distbetween == None:
			distbetween = dist
		if dist > maxdist:
			(maxdist, farnode) = (dist, node)
		for j in g[node]:
			if j not in visited:
				visited[j] = 1
				d.append([j, dist + 1])
	return [farnode, maxdist]
for _ in range(val()):
	(n, a, b, da, db) = li()
	g = defaultdict(set)
	distbetween = None
	for i in range(n - 1):
		(u, v) = li()
		g[u].add(v)
		g[v].add(u)
	farnode1 = dfs(a, b)[0]
	diameter = dfs(farnode1)[1]
	print('Bob' if distbetween > da and diameter > 2 * da and (2 * da < db) else 'Alice')


import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192

def str(x=b''):
	return x if type(x) is bytes else _str(x).encode()

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def inp():
	return sys.stdin.readline().rstrip()

def mpint():
	return map(int, inp().split(' '))

def itg():
	return int(inp())
from copy import deepcopy

def tree_bfs(tree, flat=True, start=0) -> list:
	stack = [start]
	result = []
	while stack:
		new_stack = []
		if flat:
			result.extend(stack)
		else:
			result.append(stack)
		for node in stack:
			new_stack.extend(tree[node])
		stack = new_stack
	return result

def to_graph(tree):
	for (node1, node_set) in enumerate(deepcopy(tree)):
		for node2 in node_set:
			tree[node2].add(node1)

def to_tree(graph, root=0):
	stack = [[root]]
	while stack:
		if not stack[-1]:
			del stack[-1]
			continue
		parent = stack[-1].pop()
		for child in graph[parent]:
			graph[child].discard(parent)
		stack.append(list(graph[parent]))

def tree_distance(tree, u, v):
	if u == v:
		return 0
	graph = deepcopy(tree)
	to_graph(graph)
	curr = {u}
	step = 1
	while True:
		nxt = set()
		for node in curr:
			if v in graph[node]:
				return step
			nxt |= graph[node]
		curr = nxt
		step += 1

def tree_diameter(tree):
	node1 = tree_bfs(tree)[-1]
	tree2 = deepcopy(tree)
	to_graph(tree2)
	to_tree(tree2, node1)
	bfs_data = tree_bfs(tree2, False, node1)
	node2 = bfs_data[-1][-1]
	return (node1, node2, len(bfs_data))

def solve():
	(n, a, b, da, db) = mpint()
	a -= 1
	b -= 1
	tree = [set() for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = mpint()
		u -= 1
		v -= 1
		tree[u].add(v)
		tree[v].add(u)
	if db - da < 2:
		return True
	to_tree(tree)
	if tree_distance(tree, a, b) <= da:
		return True
	longest = tree_diameter(tree)[2]
	dis = longest >> 1
	return dis <= da or db < da * 2 + 1

def main():
	for _ in range(itg()):
		print('Alice' if solve() else 'Bob')
DEBUG = 0
URL = 'https://codeforces.com/contest/1405/problem/D'
if DEBUG == 1:
	import requests
	from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
	runner = TestCaseRunner(main, URL)
	inp = runner.input_stream
	print = runner.output_stream
	runner.checking()
elif DEBUG == 2:
	main()
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	main()


import sys

class node:

	def __init__(self, i):
		self.i = i
		self.lvl1 = 0
		self.lvl2 = 0
		self.neighbour = []

def dfs1(n, p, visited):
	visited[n] = 1
	for i in p[n].neighbour:
		if visited[i.i] == 0:
			i.lvl1 = p[n].lvl1 + 1
			dfs1(i.i, p, visited)
t = int(sys.stdin.readline())
while t:
	(n, a, b, da, db) = map(int, sys.stdin.readline().split())
	p = []
	m = n - 1
	for i in range(1, n + 1):
		a1 = node(i - 1)
		p.append(a1)
	for i in range(m):
		(u, v) = map(int, sys.stdin.readline().split())
		u -= 1
		v -= 1
		p[u].neighbour.append(p[v])
		p[v].neighbour.append(p[u])
	if db <= 2 * da:
		sys.stdout.write('Alice' + '\n')
		t -= 1
		continue
	visited = [0] * n
	dfs1(a - 1, p, visited)
	dab = p[b - 1].lvl1
	if dab <= da:
		sys.stdout.write('Alice' + '\n')
		t -= 1
		continue
	for i in range(n):
		p[i].lvl1 = 0
	visited = [0] * n
	dfs1(0, p, visited)
	k = 0
	max = -1
	for i in range(len(p)):
		if p[i].lvl1 > max:
			k = i
			max = p[i].lvl1
		p[i].lvl1 = 0
	visited = [0] * n
	dfs1(k, p, visited)
	k = 0
	max = -1
	for i in range(len(p)):
		if p[i].lvl1 > max:
			k = i
			max = p[i].lvl1
	diameter = max
	if 2 * da >= diameter:
		sys.stdout.write('Alice' + '\n')
	else:
		sys.stdout.write('Bob' + '\n')
	t -= 1


import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict

class Graph:

	def __init__(self, vertices):
		self.graph = [defaultdict() for _ in range(vertices)]
		self.V = vertices

	def add_edge(self, u, v, w=1):
		self.graph[u][v] = w
		self.graph[v][u] = w

	def dfs(self, u, dist, d=0):
		dist[u] = d
		for v in self.graph[u]:
			if dist[v] == None:
				self.dfs(v, dist, d + 1)

def main():
	for _ in range(int(input())):
		(n, a, b, da, db) = map(int, input().split())
		a -= 1
		b -= 1
		g = Graph(n)
		for _ in range(n - 1):
			(u, v) = map(int, input().split())
			g.add_edge(u - 1, v - 1)
		dist = [None] * n
		g.dfs(a, dist)
		if dist[b] <= da:
			print('Alice')
		else:
			f = dist.index(max(dist))
			dist_n = [None] * n
			g.dfs(f, dist_n)
			diameter = max(dist_n)
			if 2 * da >= diameter or db <= 2 * da:
				print('Alice')
			else:
				print('Bob')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from collections import deque
import sys
input = sys.stdin.buffer.readline

def print(val):
	sys.stdout.write(str(val) + '\n')

def prog():
	for _ in range(int(input())):
		(n, a, b, da, db) = map(int, input().split())
		a -= 1
		b -= 1
		adj = [[] for i in range(n)]
		for i in range(n - 1):
			(u, v) = map(int, input().split())
			u -= 1
			v -= 1
			adj[u].append(v)
			adj[v].append(u)
		if db <= 2 * da:
			print('Alice')
		else:
			q = deque([[a, 0]])
			dist_a = [-1] * n
			while q:
				curr = q.popleft()
				if dist_a[curr[0]] == -1:
					dist_a[curr[0]] = curr[1]
					for neighbor in adj[curr[0]]:
						q.append([neighbor, curr[1] + 1])
			if dist_a[b] <= da:
				print('Alice')
			else:
				q = deque([[0, 0]])
				dist = [-1] * n
				while q:
					curr = q.popleft()
					if dist[curr[0]] == -1:
						dist[curr[0]] = curr[1]
						for neighbor in adj[curr[0]]:
							q.append([neighbor, curr[1] + 1])
				furthest_x = 0
				idx = 0
				for i in range(n):
					if dist[i] > furthest_x:
						furthest_x = dist[i]
						idx = i
				q = deque([[idx, 0]])
				dist2 = [-1] * n
				while q:
					curr = q.popleft()
					if dist2[curr[0]] == -1:
						dist2[curr[0]] = curr[1]
						for neighbor in adj[curr[0]]:
							q.append([neighbor, curr[1] + 1])
				furthest_y = max(dist2)
				diameter = furthest_y
				if diameter >= 2 * da + 1:
					print('Bob')
				else:
					print('Alice')
prog()


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	(n, a, b, da, db) = map(int, input().split())
	C = [list(map(int, input().split())) for j in range(n - 1)]
	for j in range(n - 1):
		for k in range(2):
			C[j][k] -= 1
	a -= 1
	b -= 1
	M = [[] for j in range(n)]
	for j in range(n - 1):
		M[C[j][0]].append(C[j][1])
		M[C[j][1]].append(C[j][0])
	V = [-1] * n
	V[a] = 0
	Q = [[a, 0]]
	s = 0
	while len(Q) > s:
		V[Q[s][0]] = Q[s][1]
		for x in M[Q[s][0]]:
			if V[x] == -1:
				Q.append([x, Q[s][1] + 1])
		s += 1
	mi = V.index(max(V))
	if V[b] <= da:
		print('Alice')
		continue
	V = [-1] * n
	V[mi] = 0
	Q = [[mi, 0]]
	s = 0
	while len(Q) > s:
		V[Q[s][0]] = Q[s][1]
		for x in M[Q[s][0]]:
			if V[x] == -1:
				Q.append([x, Q[s][1] + 1])
		s += 1
	mi = V.index(max(V))
	if db >= da * 2 + 1 and max(V) >= da * 2 + 1:
		print('Bob')
	else:
		print('Alice')


from fractions import Fraction
import bisect
import os
import io
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate
from queue import Queue

def input():
	return sys.stdin.readline().strip()

def iinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def rlinput():
	return list(rinput())
mod = int(1000000000.0) + 7

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))

def dfs(node, g, n):
	depth = [-1] * (n + 1)
	depth[node] = 0
	stk = deque()
	stk.append(node)
	while stk:
		node = stk.pop()
		for child in g[node]:
			if depth[child] == -1:
				depth[child] = depth[node] + 1
				stk.append(child)
	return depth
t = 1
t = iinput()
for i in range(t):
	(n, a, b, da, db) = rinput()
	g = defaultdict(list)
	for i in range(n - 1):
		(u, v) = rinput()
		g[u].append(v)
		g[v].append(u)
	depth = dfs(a, g, n)
	maxNode = -1
	maxDist = -1
	for i in range(1, n + 1):
		if depth[i] > maxDist:
			maxDist = depth[i]
			maxNode = i
	diameter = max(dfs(maxNode, g, n))
	bob = True
	if da >= depth[b] or 2 * da >= diameter or 2 * da >= db:
		bob = False
	print(['Alice', 'Bob'][bob])


from sys import stdin

class Problem:

	def __init__(self, n, a, b, da, db, e):
		self.n = n
		self.a = a - 1
		self.b = b - 1
		self.da = da
		self.db = db
		self.g = [[] for i in range(n)]
		for (u, v) in e:
			self.g[u - 1].append(v - 1)
			self.g[v - 1].append(u - 1)

	def dfs(self, v, dist=0):
		self.d[v] = dist
		for u in self.g[v]:
			if self.d[u] == None:
				self.dfs(u, dist + 1)

	def solve(self):
		if self.da * 2 >= self.db:
			return 'Alice'
		self.d = [None for i in range(self.n)]
		self.dfs(self.a)
		if self.d[self.b] <= self.da:
			return 'Alice'
		f = self.d.index(max(self.d))
		self.d = [None for i in range(self.n)]
		self.dfs(f)
		d = max(self.d)
		if self.da * 2 >= d:
			return 'Alice'
		return 'Bob'

def test_cases():
	cases = int(stdin.readline())
	for case in range(cases):
		(n, a, b, da, db) = list(map(int, stdin.readline().split()))
		e = [list(map(int, stdin.readline().split())) for i in range(n - 1)]
		yield Problem(n, a, b, da, db, e)
for test in test_cases():
	ans = test.solve()
	print(ans)


import math, sys
from collections import defaultdict, deque
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')

def I():
	return int(sys.stdin.readline())

def In():
	return map(int, sys.stdin.readline().split())

def Sn():
	return sys.stdin.readline().strip()

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

class Dfs:

	def __init__(self, d, n):
		self.d = d
		self.n = n
		self.visit = [False for x in range(n + 1)]

	def dfs(self, start=1):
		q = deque([start])
		while q:
			node = q.popleft()
			self.visit[node] = True
			for x in self.d[node]:
				if self.visit[x] == False:
					q.appendleft(x)

	def dfs_further(self, start=1):
		height = [-1 for x in range(self.n + 1)]
		height[start] = 0
		q = deque([start])
		(ma, Node_last) = (0, -1)
		while q:
			node = q.popleft()
			for x in self.d[node]:
				if height[x] == -1:
					height[x] = height[node] + 1
					if height[x] > ma:
						(ma, Node_last) = (height[x], x)
					q.appendleft(x)
		return [Node_last, ma]

def bfs(d, n, start, end):
	height = [-1 for x in range(n + 1)]
	height[start] = 0
	q = deque([start])
	while q:
		temp = q.popleft()
		for x in d[temp]:
			if height[x] == -1:
				height[x] = height[temp] + 1
				q.append(x)
	return height[end] - height[start]

def main():
	try:
		d = defaultdict(list)
		(n, A, B, da, db) = In()
		for i in range(n - 1):
			(a, b) = In()
			d[a].append(b)
			d[b].append(a)
		dfs = Dfs(d, n)
		far_node = dfs.dfs_further()[0]
		tree_length = dfs.dfs_further(start=far_node)[1]
		dist = bfs(d, n, A, B)
		if dist <= da:
			print('Alice')
		elif 2 * da >= tree_length:
			print('Alice')
		elif db > 2 * da:
			print('Bob')
		else:
			print('Alice')
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(I()):
	main()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	dic = {}
	dis = {}
	for i in range(1, n + 1):
		dic[i] = []
		dis[i] = 0
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		dic[x].append(y)
		dic[y].append(x)
	se = {a}
	ne = {a}
	level = 1
	while ne:
		tem = set({})
		for i in ne:
			xx = dic[i]
			for j in xx:
				if not j in se:
					se.add(j)
					tem.add(j)
					dis[j] = level
		ne = tem.copy()
		level += 1
	ma = max(list(dic.keys()), key=lambda x: dis[x])
	dab = dis[b]
	dis[ma] = 0
	se = {ma}
	ne = {ma}
	level = 1
	while ne:
		tem = set({})
		for i in ne:
			xx = dic[i]
			for j in xx:
				if not j in se:
					se.add(j)
					tem.add(j)
					dis[j] = level
		ne = tem.copy()
		level += 1
	diam = max(list(dis.values()))
	if dab <= da:
		print('Alice')
	elif diam <= 2 * da:
		print('Alice')
	elif db > 2 * da:
		print('Bob')
	elif db <= 2 * da:
		print('Alice')


from sys import stdin

def input():
	return stdin.readline().strip()
tests = int(input())
for t in range(tests):
	(n, a, b, da, db) = list(map(int, input().split()))
	edge_ls = [[] for _ in range(n + 1)]
	for _ in range(n - 1):
		(e1, e2) = list(map(int, input().split()))
		edge_ls[e1].append(e2)
		edge_ls[e2].append(e1)
	if da * 2 < db:
		stack = [[a, 0]]
		visited = [False for _ in range(n + 1)]
		visited[a] = True
		found = None
		furthest_edge = None
		furthest_dist = -1
		while stack:
			(curr, curr_step) = stack.pop(-1)
			if curr_step > furthest_dist:
				furthest_dist = curr_step
				furthest_edge = curr
			for item in edge_ls[curr]:
				if not visited[item]:
					stack.append([item, curr_step + 1])
					visited[item] = True
					if item == b:
						found = curr_step + 1
		stack = [[furthest_edge, 1]]
		visited = [False for _ in range(n + 1)]
		visited[furthest_edge] = True
		furthest_dist = -1
		while stack:
			(curr, curr_step) = stack.pop(-1)
			if curr_step > furthest_dist:
				furthest_dist = curr_step
			for item in edge_ls[curr]:
				if not visited[item]:
					stack.append([item, curr_step + 1])
					visited[item] = True
		if found > da and furthest_dist >= da * 2 + 2:
			print('Bob')
		else:
			print('Alice')
	else:
		print('Alice')


import os, io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def distance(graph, u, v):
	visited = {i: True for i in graph}
	stack = [(u, 0)]
	rp = 0
	while stack:
		(node, p) = stack.pop()
		if node == v:
			rp = p
			break
		if visited[node]:
			visited[node] = False
			for i in graph[node]:
				if visited[i]:
					stack.append((i, p + 1))
	return rp

def diameter(graph, root):
	visited = {i: True for i in graph}

	def inner(visited, root):
		diam = 0
		hl = []
		if visited[root]:
			visited[root] = False
			for i in graph[root]:
				if visited[i]:
					(h, diam1) = inner(visited, i)
					hl.append(h)
					diam = max(diam, diam1)
		hl.extend([0, 0])
		(h1, h2) = sorted(hl, reverse=True)[:2]
		return (max(h1, h2) + 1, max(diam, h1 + h2 + 1))
	(_, diam) = inner(visited, root)
	return diam
cases = int(input())
for t in range(cases):
	(n, a, b, da, db) = list(map(int, input().split()))
	if db <= 2 * da:
		for i in range(n - 1):
			_ = input()
		print('Alice')
	else:
		graph = {i + 1: [] for i in range(n)}
		for i in range(n - 1):
			(u, v) = list(map(int, input().split()))
			graph[u].append(v)
			graph[v].append(u)
		ab = distance(graph, a, b)
		if ab <= da:
			print('Alice')
		else:
			diam = diameter(graph, 1)
			if da >= diam // 2:
				print('Alice')
			else:
				print('Bob')


from sys import stdin
input = stdin.readline
q = int(input())
for _ in range(q):
	(n, sa, sb, a, b) = map(int, input().split())
	sa -= 1
	sb -= 1
	nbr = [[] for i in range(n)]
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		x -= 1
		y -= 1
		nbr[x].append(y)
		nbr[y].append(x)
	if 2 * a >= b:
		print('Alice')
	else:
		q = [sa]
		ind = 0
		dist = [-1] * n
		dist[sa] = 0
		while q:
			if ind >= len(q):
				break
			v = q[ind]
			ind += 1
			for w in nbr[v]:
				if dist[w] == -1:
					q.append(w)
					dist[w] = dist[v] + 1
		if dist[sb] <= a:
			print('Alice')
		else:
			q = [0]
			ind = 0
			dist = [-1] * n
			dist[0] = 0
			while q:
				if ind >= len(q):
					break
				v = q[ind]
				ind += 1
				for w in nbr[v]:
					if dist[w] == -1:
						q.append(w)
						dist[w] = dist[v] + 1
			maksik = 0
			best = 0
			for i in range(n):
				if dist[i] > maksik:
					best = i
					maksik = dist[i]
			q = [best]
			ind = 0
			dist = [-1] * n
			dist[best] = 0
			while q:
				if ind >= len(q):
					break
				v = q[ind]
				ind += 1
				for w in nbr[v]:
					if dist[w] == -1:
						q.append(w)
						dist[w] = dist[v] + 1
			if max(dist) > 2 * a:
				print('Bob')
			else:
				print('Alice')


import sys
from collections import deque
pprint = lambda s: print(' '.join(map(lambda x: str(x), s)))
input = lambda : sys.stdin.readline().strip()
ipnut = input
mod = 1000000007
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	a -= 1
	b -= 1
	g = [[] for _ in range(n)]
	for i in range(n - 1):
		(a1, b1) = map(int, input().split())
		a1 -= 1
		b1 -= 1
		g[a1].append(b1)
		g[b1].append(a1)
	if 2 * da + 1 > db:
		print('Alice')
		continue
	bfs = deque()
	bfs.append(b)
	lvl = [-1] * n
	lvl[b] = 0
	while bfs:
		v = bfs.popleft()
		for u in g[v]:
			if lvl[u] == -1:
				lvl[u] = lvl[v] + 1
				bfs.append(u)
	if lvl[a] <= da:
		print('Alice')
		continue
	m = max(lvl)
	a = lvl.index(m)
	bfs.append(a)
	lvl = [-1] * n
	lvl[a] = 0
	while bfs:
		v = bfs.popleft()
		for u in g[v]:
			if lvl[u] == -1:
				lvl[u] = lvl[v] + 1
				bfs.append(u)
	d = max(lvl)
	if d < 2 * da + 1:
		print('Alice')
	else:
		print('Bob')


import io
import os
from collections import Counter, defaultdict, deque

def bfs(source, getNbr):
	q = deque([source])
	dist = {source: 0}
	while q:
		node = q.popleft()
		d = dist[node]
		for nbr in getNbr(node):
			if nbr not in dist:
				q.append(nbr)
				dist[nbr] = d + 1
	return dist

def longestPathFrom(root, getNbr):
	assert root
	queue = deque([root])
	parent = {root: None}
	while queue:
		curr = queue.popleft()
		for child in getNbr(curr):
			if child not in parent:
				queue.append(child)
				parent[child] = curr
	ret = [curr]
	while curr in parent and parent[curr]:
		curr = parent[curr]
		ret.append(curr)
	return ret[::-1]

def treeDiameter(graph):
	initNode = 1

	def getNbr(node):
		return graph[node]
	path1 = longestPathFrom(initNode, getNbr)
	assert path1[0] == initNode
	path2 = longestPathFrom(path1[-1], getNbr)
	return path2

def solve(N, A, B, DA, DB, edges):
	graph = [[] for i in range(N + 1)]
	for (u, v) in edges:
		graph[u].append(v)
		graph[v].append(u)

	def getNbr(node):
		return graph[node]
	dist = bfs(A, getNbr)
	if dist[B] <= DA:
		return 'Alice'
	diameter = treeDiameter(graph)
	if 2 * DA >= len(diameter) - 1:
		return 'Alice'
	if DB > 2 * DA:
		return 'Bob'
	return 'Alice'
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
	(N, A, B, DA, DB) = [int(x) for x in input().split()]
	edges = [[int(x) for x in input().split()] for i in range(N - 1)]
	ans = solve(N, A, B, DA, DB, edges)
	print(ans)


from collections import defaultdict

class Graph:

	def __init__(self, vertices):
		self.graph = [defaultdict() for _ in range(vertices + 1)]
		self.V = vertices + 1

	def add_edge(self, u, v, w=1):
		self.graph[u][v] = w
		self.graph[v][u] = w

	def dfs_util(self, u, count, mxcount, visited, x):
		visited[u] = True
		count += 1
		for v in self.graph[u]:
			if not visited[v]:
				if count > mxcount[0]:
					mxcount[0] = count
					x[0] = v
				self.dfs_util(v, count, mxcount, visited, x)

	def dfs(self, u, mxcount, x):
		visited = [False] * self.V
		count = 0
		self.dfs_util(u, count, mxcount, visited, x)

	def dia(self):
		mxcount = [float('-inf')]
		x = [0]
		self.dfs(1, mxcount, x)
		self.dfs(x[0], mxcount, x)
		return mxcount[0]

	def dfs_dist(self, u, b, dist, ans, visited):
		visited[u] = True
		for v in self.graph[u]:
			if not visited[v]:
				if v == b:
					ans[0] = dist
				else:
					self.dfs_dist(v, b, dist + 1, ans, visited)

	def dist(self, a, b):
		visited = [False] * self.V
		ans = [0]
		self.dfs_dist(a, b, 1, ans, visited)
		return ans[0]
for _ in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	g = Graph(n)
	indeg = [0] * n
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		g.add_edge(u, v)
	dist = g.dist(a, b)
	dia = g.dia()
	if dist <= da:
		print('Alice')
	elif 2 * da >= dia:
		print('Alice')
	elif db > 2 * da:
		print('Bob')
	else:
		print('Alice')


import sys
input = sys.stdin.readline
for f in range(int(input())):
	(n, a, b, da, db) = map(int, input().split())
	neig = [0] * n
	for i in range(n):
		neig[i] = [0]
	for i in range(n - 1):
		(vertexa, vertexb) = map(int, input().split())
		vertexa -= 1
		vertexb -= 1
		neig[vertexa][0] += 1
		neig[vertexb][0] += 1
		neig[vertexa].append(vertexb)
		neig[vertexb].append(vertexa)
	height = [0] * n
	dn = [-1] * n
	diam = 0
	tod = []
	for i in range(n):
		if neig[i][0] == 1:
			tod.append(i)
	while len(tod) > 0:
		x = tod.pop()
		neig[x][0] = 0
		for i in range(1, len(neig[x])):
			ng = neig[x][i]
			if neig[ng][0] > 0:
				neig[ng][0] -= 1
				diam = max(diam, height[ng] + height[x] + 1)
				height[ng] = max(height[ng], height[x] + 1)
				if neig[ng][0] == 1:
					tod.append(ng)
				dn[x] = ng
	dist = 0
	a -= 1
	b -= 1
	while a != b:
		dist += 1
		if height[a] < height[b]:
			a = dn[a]
		else:
			b = dn[b]
	if dist <= da or 2 * da >= db or 2 * da >= diam:
		print('Alice')
	else:
		print('Bob')


import atexit
from io import StringIO
import sys
input = iter(sys.stdin.read().splitlines()).__next__
sys.stdout = StringIO()
atexit.register(lambda : sys.__stdout__.write(sys.stdout.getvalue()))

def furthest(graph, source):
	S = [(source, 0)]
	furthest_node = source
	furthest_dist = 0
	discovered = [False] * len(graph)
	while S:
		(u, dist) = S.pop()
		if dist > furthest_dist:
			furthest_node = u
			furthest_dist = dist
		if discovered[u]:
			continue
		discovered[u] = True
		for v in graph[u]:
			S.append((v, dist + 1))
	return (furthest_node, furthest_dist)

def distance(graph, source, dest):
	S = [(source, 0)]
	discovered = set()
	while S:
		(u, dist) = S.pop()
		if u == dest:
			return dist
		if u in discovered:
			continue
		discovered.add(u)
		for v in graph[u]:
			S.append((v, dist + 1))
t = int(input())
for _ in range(t):
	(n, a, b, da, db) = map(int, input().split())
	if da + da >= db:
		for edge in range(n - 1):
			input()
		print('Alice')
		continue
	graph = [[] for node in range(n)]
	for edge in range(n - 1):
		(u, v) = [int(i) - 1 for i in input().split()]
		graph[u].append(v)
		graph[v].append(u)
	if distance(graph, a - 1, b - 1) <= da:
		print('Alice')
		continue
	diameter = furthest(graph, furthest(graph, 0)[0])[1]
	if da + da >= diameter:
		print('Alice')
	else:
		print('Bob')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, sa, sb, da, db) = map(int, input().split())
	e = {}
	g = 0
	if 2 * da >= db:
		exec((n - 1) * 'input();')
		print('Alice')
		continue
	for i in range(n):
		e[i] = []
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		e[u - 1] += [v - 1]
		e[v - 1] += [u - 1]
	s = []
	d = [[None] * 2 + [0] * 2 for i in range(n)]
	q = [(0, -1)]
	while q:
		(v, p) = q.pop()
		if v == sa - 1:
			d[v][0] = 0
		elif v == sb - 1:
			d[v][1] = 0
		if v < 1 or len(e[v]) > 1:
			s.append((v, p))
			for i in e[v]:
				if i != p:
					q.append((i, v))
	while s:
		(v, p) = s.pop()
		m = [0, 0]
		b = 0
		for i in e[v]:
			if i != p:
				w = d[i][2]
				if w > m[0]:
					m = [w, m[0]]
				elif w > m[1]:
					m = [m[0], w]
				b = max(b, d[i][3])
				w = d[i][0]
				if w != None:
					d[v][0] = w + 1
				w = d[i][1]
				if w != None:
					d[v][1] = w + 1
		d[v][2] = m[0] + 1
		d[v][3] = max(min(2, len(e[v]) - (v > 0)) + sum(m), b)
		if g < 1 and d[v][0] != None and (d[v][1] != None):
			g = d[v][0] + d[v][1]
	print(['Alice', 'Bob'][g > da and d[0][3] > 2 * da])


import sys
input = sys.stdin.readline

def f():
	(n, a, b, da, db) = map(int, input().split())
	T = [[] for _ in range(n + 1)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		T[u].append(v)
		T[v].append(u)
	dist = [-1] * (n + 1)
	dist[a] = 0
	m = 0
	v = -1
	stack = [a]
	while stack:
		i = stack.pop()
		for nv in T[i]:
			if dist[nv] != -1:
				continue
			dist[nv] = dist[i] + 1
			if m < dist[nv]:
				m = dist[nv]
				v = nv
			stack.append(nv)
	if dist[b] <= da:
		print('Alice')
		return
	m = 0
	stack = [v]
	dist = [-1] * (n + 1)
	dist[v] = 0
	while stack:
		i = stack.pop()
		for nv in T[i]:
			if dist[nv] != -1:
				continue
			dist[nv] = dist[i] + 1
			if m < dist[nv]:
				m = dist[nv]
			stack.append(nv)
	if 2 * da >= m:
		print('Alice')
		return
	if db <= 2 * da:
		print('Alice')
	else:
		print('Bob')
t = int(input())
for x in range(t):
	f()