import java.io.*;
import java.util.*;

public class Coding {

    static long MOD = 1000000007;
    static long[] fact = new long[100002];
    static long[] pow2 = new long[100002];

    public static void main(String[] args) {
        BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        //precompute();
        try {
            int t = Integer.parseInt(bi.readLine());
            while (t > 0) {
               String[] inputs = bi.readLine().split(" ");
               int n = Integer.parseInt(inputs[0].trim());
               int a = Integer.parseInt(inputs[1].trim());
               int b = Integer.parseInt(inputs[2].trim());
               int da = Integer.parseInt(inputs[3].trim());
               int db = Integer.parseInt(inputs[4].trim());
               int[] par = new int[n+1];
               int[] dep = new int[n+1];
               List<Integer>[] adj = new ArrayList[n+1];
               for(int i=0;i<=n;++i) {
                   adj[i] = new ArrayList<>();
                   par[i] = -1;
                   dep[i] = 0;
               }
               for(int i=1;i<=n-1;++i) {
                   String input = bi.readLine();
                   int x = Integer.parseInt(input.split(" ")[0].trim());
                   int y = Integer.parseInt(input.split(" ")[1].trim());
                   adj[x].add(y);
                   adj[y].add(x);
               }
               dfs(1, adj, par, dep,-1);
               int dist = findDist(a, b, par);
               if (dist<=da) {
                   writer.append("Alice");
               } else {
                   int diameter = findLongestPath(1, -1, adj, dep);
                   if (2*da>=diameter) {
                       writer.append("Alice");
                   } else {
                       if (db>2*da) {
                           writer.append("Bob");
                       } else {
                           writer.append("Alice");
                       }
                   }
               }
               writer.append('\n');
               writer.flush();
               t--;
            }
            writer.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void dfs(int cur, List<Integer>[] adj, int[] par, int[] dep, int parent) {
        par[cur] = parent;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=parent) {
                dfs(nxt, adj, par, dep, cur);
                dep[cur] = Math.max(dep[cur], dep[nxt]+1);
            }
        }
    }

    private static int findDist(int a, int b, int[] par) {
        Map<Integer, Integer> dist = new HashMap<>();
        int count = 0;
        dist.put(a, 0);
        while (par[a]!=-1) {
            a = par[a];
            count++;
            dist.put(a, count);
        }
        count=0;
        while(!dist.containsKey(b)) {
            b = par[b];
            count++;
        }
        return count+dist.get(b);
    }

    private static int findLongestPath(int cur, int prev, List<Integer>[] adj, int[] dep) {
        int diameter = 0;
        int highest = -1, second=-1;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=prev) {
                diameter = Math.max(diameter, findLongestPath(nxt, cur, adj, dep));
            }
            if (dep[nxt]>highest) {
                second = highest;
                highest = dep[nxt];
            } else if (dep[nxt]>second) {
                second = dep[nxt];
            }
        }
        diameter = Math.max(diameter, highest + second + 2);
        return diameter;
    }

    static long ncr(int n, int r) {
        long num = fact[n];
        long denom = (modExp(fact[r], MOD-2)*modExp(fact[n-r], MOD-2))%MOD;
        //System.out.println("num is " + num + " denom is" + denom);
        return (num*denom)%MOD;
    }

    static long modExp(long a, long b) {
        //System.out.println("a is " + a + " and b is " + b);
        if (a==1) return 1;
        long ans = 1;
        while (b!=0) {
            if (b%2==1) {
                ans = (ans*a)%MOD;
            }
            a = (a*a)%MOD;
            b/=2;
        }
        return ans;
    }

    private static void precompute() {
        fact[0] = 1;
        pow2[0] = 1;
        for(int i=1;i<=100000;++i) {
            fact[i] = (fact[i-1]*i)%MOD;
            pow2[i] = (pow2[i-1]*2)%MOD;
        }
    }
}


import java.io.*;
import java.util.*;

public class Coding {

    static long MOD = 1000000007;
    static long[] fact = new long[100002];
    static long[] pow2 = new long[100002];

    public static void main(String[] args) {
        BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        //precompute();
        try {
            int t = Integer.parseInt(bi.readLine());
            while (t > 0) {
               String[] inputs = bi.readLine().split(" ");
               int n = Integer.parseInt(inputs[0].trim());
               int a = Integer.parseInt(inputs[1].trim());
               int b = Integer.parseInt(inputs[2].trim());
               int da = Integer.parseInt(inputs[3].trim());
               int db = Integer.parseInt(inputs[4].trim());
               int[] par = new int[n+1];
               int[] dep = new int[n+1];
               List<Integer>[] adj = new ArrayList[n+1];
               for(int i=0;i<=n;++i) {
                   adj[i] = new ArrayList<>();
                   par[i] = -1;
                   dep[i] = 0;
               }
               for(int i=1;i<=n-1;++i) {
                   String input = bi.readLine();
                   int x = Integer.parseInt(input.split(" ")[0].trim());
                   int y = Integer.parseInt(input.split(" ")[1].trim());
                   adj[x].add(y);
                   adj[y].add(x);
               }
               dfs(1, adj, par, dep,-1);
               int dist = findDist(a, b, par);
               if (dist<=da) {
                   writer.append("Alice");
               } else {
                   int diameter = findLongestPath(1, -1, adj, dep);
                   if (2*da>=diameter) {
                       writer.append("Alice");
                   } else {
                       if (db>2*da) {
                           writer.append("Bob");
                       } else {
                           writer.append("Alice");
                       }
                   }
               }
               writer.append('\n');
               writer.flush();
               t--;
            }
            writer.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void dfs(int cur, List<Integer>[] adj, int[] par, int[] dep, int parent) {
        par[cur] = parent;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=parent) {
                dfs(nxt, adj, par, dep, cur);
                dep[cur] = Math.max(dep[cur], dep[nxt]+1);
            }
        }
    }

    private static int findDist(int a, int b, int[] par) {
        Map<Integer, Integer> dist = new HashMap<>();
        int count = 0;
        dist.put(a, 0);
        while (par[a]!=-1) {
            a = par[a];
            count++;
            dist.put(a, count);
        }
        count=0;
        while(!dist.containsKey(b)) {
            b = par[b];
            count++;
        }
        return count+dist.get(b);
    }

    private static int findLongestPath(int cur, int prev, List<Integer>[] adj, int[] dep) {
        int diameter = 0;
        int highest = -1, second=-1;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=prev) {
                diameter = Math.max(diameter, findLongestPath(nxt, cur, adj, dep));
                if (dep[nxt]>highest) {
                    second = highest;
                    highest = dep[nxt];
                } else if (dep[nxt]>second) {
                    second = dep[nxt];
                }
            }
        }
        diameter = Math.max(diameter, highest + second + 2);
        return diameter;
    }

    static long ncr(int n, int r) {
        long num = fact[n];
        long denom = (modExp(fact[r], MOD-2)*modExp(fact[n-r], MOD-2))%MOD;
        //System.out.println("num is " + num + " denom is" + denom);
        return (num*denom)%MOD;
    }

    static long modExp(long a, long b) {
        //System.out.println("a is " + a + " and b is " + b);
        if (a==1) return 1;
        long ans = 1;
        while (b!=0) {
            if (b%2==1) {
                ans = (ans*a)%MOD;
            }
            a = (a*a)%MOD;
            b/=2;
        }
        return ans;
    }

    private static void precompute() {
        fact[0] = 1;
        pow2[0] = 1;
        for(int i=1;i<=100000;++i) {
            fact[i] = (fact[i-1]*i)%MOD;
            pow2[i] = (pow2[i-1]*2)%MOD;
        }
    }
}


import java.io.*;
import java.util.*;

public class Coding {

    static long MOD = 1000000007;
    static long[] fact = new long[100002];
    static long[] pow2 = new long[100002];

    public static void main(String[] args) {
        BufferedReader bi = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
        //precompute();
        try {
            int t = Integer.parseInt(bi.readLine());
            while (t > 0) {
               String[] inputs = bi.readLine().split(" ");
               int n = Integer.parseInt(inputs[0].trim());
               int a = Integer.parseInt(inputs[1].trim());
               int b = Integer.parseInt(inputs[2].trim());
               int da = Integer.parseInt(inputs[3].trim());
               int db = Integer.parseInt(inputs[4].trim());
               int[] par = new int[n+1];
               int[] dep = new int[n+1];
               List<Integer>[] adj = new ArrayList[n+1];
               for(int i=0;i<=n;++i) {
                   adj[i] = new ArrayList<>();
                   par[i] = -1;
                   dep[i] = 0;
               }
               for(int i=1;i<=n-1;++i) {
                   String input = bi.readLine();
                   int x = Integer.parseInt(input.split(" ")[0].trim());
                   int y = Integer.parseInt(input.split(" ")[1].trim());
                   adj[x].add(y);
                   adj[y].add(x);
               }
               dfs(1, adj, par, dep,-1);
               int dist = findDist(a, b, par);
               if (dist<=da) {
                   writer.append("Alice");
               } else {
                   int diameter = findLongestPath(1, -1, adj, dep);
                   if (2*da>=diameter) {
                       writer.append("Alice");
                   } else {
                       if (db>2*da) {
                           writer.append("Bob");
                       } else {
                           writer.append("Alice");
                       }
                   }
               }
               writer.append('\n');
               writer.flush();
               t--;
            }
            writer.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void dfs(int cur, List<Integer>[] adj, int[] par, int[] dep, int parent) {
        par[cur] = parent;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=parent) {
                dfs(nxt, adj, par, dep, cur);
                dep[cur] = Math.max(dep[cur], dep[nxt]+1);
            }
        }
    }

    private static int findDist(int a, int b, int[] par) {
        Map<Integer, Integer> dist = new HashMap<>();
        int count = 0;
        while (par[a]!=-1) {
            a = par[a];
            count++;
            dist.put(a, count);
        }
        count=0;
        while(!dist.containsKey(b)) {
            b = par[b];
            count++;
        }
        return count+dist.get(b);
    }

    private static int findLongestPath(int cur, int prev, List<Integer>[] adj, int[] dep) {
        int diameter = 0;
        int highest = -1, second=-1;
        for(int i=0;i<adj[cur].size();++i) {
            int nxt = adj[cur].get(i);
            if (nxt!=prev) {
                diameter = Math.max(diameter, findLongestPath(nxt, cur, adj, dep));
            }
            if (dep[nxt]>highest) {
                highest = dep[nxt];
                second = highest;
            } else if (dep[nxt]>second) {
                second = dep[nxt];
            }
        }
        diameter = Math.max(diameter, highest + second + 2);
        return diameter;
    }

    static long ncr(int n, int r) {
        long num = fact[n];
        long denom = (modExp(fact[r], MOD-2)*modExp(fact[n-r], MOD-2))%MOD;
        //System.out.println("num is " + num + " denom is" + denom);
        return (num*denom)%MOD;
    }

    static long modExp(long a, long b) {
        //System.out.println("a is " + a + " and b is " + b);
        if (a==1) return 1;
        long ans = 1;
        while (b!=0) {
            if (b%2==1) {
                ans = (ans*a)%MOD;
            }
            a = (a*a)%MOD;
            b/=2;
        }
        return ans;
    }

    private static void precompute() {
        fact[0] = 1;
        pow2[0] = 1;
        for(int i=1;i<=100000;++i) {
            fact[i] = (fact[i-1]*i)%MOD;
            pow2[i] = (pow2[i-1]*2)%MOD;
        }
    }
}


// Utilities
import java.io.*;
import java.util.*;

public class Main {
	static int T;
	static int N, a, b, da, db;
	static ArrayList<Integer>[] adj;
	static int u, v;
	static int diameter;
	static int[] dist;

	public static void main(String[] args) throws IOException {
		T = in.iscan();
		while (T-- > 0) {
			N = in.iscan(); a = in.iscan(); b = in.iscan(); da = in.iscan(); db = in.iscan();
			adj = new ArrayList[N+1];
			for (int i = 0; i <= N; i++) adj[i] = new ArrayList();
			for (int i = 0; i < N-1; i++) {
				u = in.iscan(); v = in.iscan();
				adj[u].add(v); adj[v].add(u);
			}
			if (db <= 2*da) {
				out.println("Alice");
				continue;
			}
			dist = new int[N+1];
			farthestNode = b; maxDist = 0;
			dfs(b, -1);
			if (dist[a] <= da) {
				out.println("Alice");
				continue;
			}
			dist = new int[N+1];
			dfs(farthestNode, -1);
			diameter = maxDist;
			if (diameter <= 2 * da) {
				out.println("Alice");
				continue;
			}
			out.println("Bob");
		}
		out.close();
	}

	static int farthestNode, maxDist;
	static void dfs(int idx, int prev) {
		for (int u : adj[idx]) {
			if (u != prev) {
				dist[u] = dist[idx]+1;
				if (dist[u] > maxDist) {
					maxDist = dist[u];
					farthestNode = u;
				}
				dfs(u, idx);
			}
		}
	}

	static INPUT in = new INPUT(System.in);
	static PrintWriter out = new PrintWriter(System.out);
	private static class INPUT {

		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public INPUT (InputStream stream) {
			this.stream = stream;
		}

		public INPUT (String file) throws IOException {
			this.stream = new FileInputStream (file);
		}

		public int cscan () throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read (buf);
			}

			if (numChars == -1)
				return numChars;

			return buf[curChar++];
		}

		public int iscan () throws IOException {
			int c = cscan (), sgn = 1;

			while (space (c))
				c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			int res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

		public String sscan () throws IOException {
			int c = cscan ();

			while (space (c))
				c = cscan ();

			StringBuilder res = new StringBuilder ();

			do {
				res.appendCodePoint (c);
				c = cscan ();
			}
			while (!space (c));

			return res.toString ();
		}

		public double dscan () throws IOException {
			int c = cscan (), sgn = 1;

			while (space (c))
				c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			double res = 0;

			while (!space (c) && c != '.') {
				if (c == 'e' || c == 'E')
					return res * UTILITIES.fast_pow (10, iscan ());

				res *= 10;
				res += c - '0';
				c = cscan ();
			}

			if (c == '.') {
				c = cscan ();
				double m = 1;

				while (!space (c)) {
					if (c == 'e' || c == 'E')
						return res * UTILITIES.fast_pow (10, iscan ());

					m /= 10;
					res += (c - '0') * m;
					c = cscan ();
				}
			}

			return res * sgn;
		}

		public long lscan () throws IOException {
			int c = cscan (), sgn = 1;

			while (space (c))
				c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			long res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

		public boolean space (int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}

	public static class UTILITIES {

		static final double EPS = 10e-6;

		public static int lower_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] >= x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int upper_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] > x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int gcd (int a, int b) {
			return b == 0 ? a : gcd (b, a % b);
		}

		public static int lcm (int a, int b) {
			return a * b / gcd (a, b);
		}

		public static long fast_pow_mod (long b, long x, int mod) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;

			return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
		}

		public static int fast_pow (int b, int x) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow (b * b, x / 2);

			return b * fast_pow (b * b, x / 2);
		}

		public static long choose (long n, long k) {
			k = Math.min (k, n - k);
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = val * (n - i) / (i + 1);

			return val;
		}

		public static long permute (int n, int k) {
			if (n < k) return 0;
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = (val * (n - i));

			return val;
		}
	}
}


import java.util.*;
import java.io.*;

public class _1405D {
    static int[] MODS = {1000000007, 998244353};
    static int MOD = MODS[0];
    static ArrayList<Integer>[] adj;
    static int[] par, distance, par2, distance2;

    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));
        int t = sc.nextInt();
        while (t-- > 0) {
            int n = sc.nextInt();
            int a = sc.nextInt();
            int b = sc.nextInt();
            int da = sc.nextInt();
            int db = sc.nextInt();
            adj = new ArrayList[n+1];
            par = new int[n+1];
            distance = new int[n+1];
            for (int i = 0; i < adj.length; i++) {
                adj[i] = new ArrayList<>();
            }
            for (int i = 0; i < n-1; i++) {
                int x = sc.nextInt();
                int y = sc.nextInt();
                adj[x].add(y);
                adj[y].add(x);
            }
            dfs(a);
            if (da >= distance[b] || db <= 2 * da) {
                out.println("Alice");
                continue;
            }
            int maxIndex = a;
            for (int i = 1; i <= n; i++) {
                if (distance[i] > distance[maxIndex]) {
                    maxIndex = i;
                }
            }
            int maxDistance = distance[maxIndex];
            par2 = new int[n+1];
            distance2 = new int[n+1];
            dfs2(maxIndex);
            for (int i = 1; i <= n; i++) {
                maxDistance = Math.max(maxDistance, distance2[i]);
            }
            if (maxDistance <= 2 * da) {
                out.println("Alice");
                continue;
            }
            out.println("Bob");
        }
        out.close();
    }

   public static void dfs2(int x) {
        for (int y: adj[x]) {
            if (y != par2[x]) {
                distance2[y] = distance2[x] + 1;
                par2[y] = x;
                dfs2(y);
            }
        }
   }

    public static void dfs(int x) {
        for (int y: adj[x]) {
            if (y != par[x]) {
                distance[y] = distance[x] + 1;
                par[y] = x;
                dfs(y);
            }
        }
    }

    public static int[] sort(int[] arr) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            list.add(arr[i]);
        }
        Collections.sort(list);
        for (int i = 0; i < arr.length; i++) {
            arr[i] = list.get(i);
        }
        return arr;
    }

    public static PrintWriter out;

    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}


import java.io.*;
import java.util.*;
import java.util.concurrent.TimeUnit;

public class d1405 implements Runnable{

    public static void main(String[] args) {
    	try{
            new Thread(null, new d1405(), "process", 1<<26).start();
        }
        catch(Exception e){
            System.out.println(e);
        }
    }
	public void run() {
		FastReader scan = new FastReader();
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		//PrintWriter out = new PrintWriter("file.out");
		Task solver = new Task();
		int t = scan.nextInt();
		//int t = 1;
		for(int i = 1; i <= t; i++) solver.solve(i, scan, out);
		out.close();
	}

	static class Task {
		static final int oo = Integer.MAX_VALUE;
		static final long OO = Long.MAX_VALUE;

		static List<List<Integer>> adj = new ArrayList<>();
		public void solve(int testNumber, FastReader sc, PrintWriter out) {
			int N = sc.nextInt();
			int A = sc.nextInt();
			int B = sc.nextInt();
			int dA = sc.nextInt();
			int dB = sc.nextInt();

			adj.clear();
			max = 0;
			for(int i = 0; i <= N; i++) {
				adj.add(new ArrayList<>());
			}
			for(int i = 1; i < N; i++) {
				int u = sc.nextInt();
				int v = sc.nextInt();
				adj.get(u).add(v);
				adj.get(v).add(u);
			}

			LCA lca = new LCA(adj, 1);
			if(lca.distance(A, B) <= dA) {
				out.println("Alice");
				return;
			}

			if(dB <= 2 * dA) {
				out.println("Alice");
				return;
			}

			// Bob wins if he can keep "jumping over" Alice, which is only possible if he's more than 2 * dA,
			// and there has to be a location where he can jump over alice in the first place
			maxDist(1, 0);
			//dbg(max);
			if(max >= 2 * dA + 1) {
				out.println("Bob");
				return;
			}

			out.println("Alice");
			return;
		}

		static int max = 0;
		public static int maxDist(int node, int parent) {
			PriorityQueue<Integer> dists = new PriorityQueue<>(Collections.reverseOrder());
			dists.add(0);
			dists.add(0);
			for(int each: adj.get(node)) {
				if(each != parent) {
					dists.add(maxDist(each, node));
				}
			}
			int a = dists.poll();
			int b = dists.peek();
			//dbg(node + " " + (a+b));
			max = Math.max(max, a + b);
			return a+1; // return the largest for further processing
		}

		public static class LCA {
			int N, L;
			List<List<Integer>> adjList;
			int timer;
			int[] tIn, tOut;
			int[][] up;
			int[] depth;

			public LCA(List<List<Integer>> adj, int root) {
				N = adj.size();
				adjList = adj;
				tIn = new int[N];
				tOut = new int[N];
				depth = new int[N];
				timer = 0;
				L = (int)Math.ceil(Math.log(N) / Math.log(2));
				up = new int[N][L+1];
				dfs(root, root, 0);
			}

			public void dfs(int node, int parent, int dep) {
				tIn[node] = timer++;
				up[node][0] = parent;
				for(int i = 1; i <= L; i++) {
					up[node][i] = up[up[node][i-1]][i-1];
				}

				depth[node] = dep;
				for(int each: adjList.get(node)) {
					if(each != parent)
						dfs(each, node, dep+1);
				}

				tOut[node] = timer++;
			}

			public boolean isAncestor(int u, int v) {
				return tIn[u] <= tIn[v] && tOut[u] >= tOut[v];
			}

			public int lca(int u, int v) {
				if(isAncestor(u, v))
					return u;
				if(isAncestor(v, u))
					return v;
				for(int i = L; i >= 0; i--) {
					if(!isAncestor(up[u][i], v))
						u = up[u][i];
				}
				return up[u][0];
			}

			public int distance(int u, int v) {
				int lca = lca(u, v);
				if(lca == u || lca == v) {
					return Math.abs(depth[v] - depth[u]);
				}
				return depth[v] - depth[lca] + depth[u] - depth[lca];
			}
		}
	}

	static long modDivide(long a, long b, long MOD) {
		a %= MOD;
		return (binpow(b, MOD-2, MOD) * a) % MOD;
	}
	static long binpow(long a, long b, long m) {
		a %= m;
		long res = 1;
		while (b > 0) {
			if ((b & 1) == 1)
				res = res * a % m;
			a = a * a % m;
			b >>= 1;
		}
		return res;
	}
	static int[] reverse(int a[])
    {
        int[] b = new int[a.length];
        for (int i = 0, j = a.length; i < a.length; i++, j--) {
            b[j - 1] = a[i];
        }

        return b;
    }
	static long[] reverse(long a[])
    {
        long[] b = new long[a.length];
        for (int i = 0, j = a.length; i < a.length; i++, j--) {
            b[j - 1] = a[i];
        }

        return b;
    }
	static void sort(int[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static void sort(long[] x){
		shuffle(x);
		Arrays.sort(x);
	}
	static class tup implements Comparable<tup>, Comparator<tup>{
		int a, b;
		tup(int a,int b){
			this.a=a;
			this.b=b;
		}
		public tup() {
		}
		@Override
		public int compareTo(tup o){
			return Integer.compare(b,o.b);
		}
		@Override
		public int compare(tup o1, tup o2) {
			return Integer.compare(o1.b, o2.b);
		}

		@Override
	    public int hashCode() {
			return Objects.hash(a, b);
	    }

	    @Override
	    public boolean equals(Object obj) {
	    	if (this == obj)
                return true;
	    	if (obj == null)
                return false;
	    	if (getClass() != obj.getClass())
                return false;
	    	tup other = (tup) obj;
	    	return a==other.a && b==other.b;
	    }

	    @Override
	    public String toString() {
	    	return a + " " + b;
	    }
	}

	static void shuffle(int[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			int temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static void shuffle(long[] a) {
		Random get = new Random();
		for (int i = 0; i < a.length; i++) {
			int r = get.nextInt(a.length);
			long temp = a[i];
			a[i] = a[r];
			a[r] = temp;
		}
	}

	static class FastReader {
		BufferedReader br;
		StringTokenizer st;

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		public FastReader(String s) throws FileNotFoundException {
			br = new BufferedReader(new FileReader(new File(s)));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}

		int[] readArray(int size) {
			int[] a = new int[size];
			for(int i = 0; i < size; i++) {
				a[i] = nextInt();
			}
			return a;
		}

		long[] readLongArray(int size) {
			long[] a = new long[size];
			for(int i = 0; i < size; i++) {
				a[i] = nextLong();
			}
			return a;
		}
	}

	static void dbg(int[] arr) {
		System.out.println(Arrays.toString(arr));
	}
	static void dbg(long[] arr) {
		System.out.println(Arrays.toString(arr));
	}
	static void dbg(boolean[] arr) {
		System.out.println(Arrays.toString(arr));
	}

	static void dbg(Object... args) {
        for (Object arg : args)
            System.out.print(arg + " ");
        System.out.println();
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.util.PriorityQueue;
import java.util.Collection;
import java.util.Set;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.AbstractCollection;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.Queue;
import java.util.LinkedList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskD solver = new TaskD();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskD {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int cases = in.nextInt();
            for (int x = 0; x < cases; x++) {
                int numVertices = in.nextInt();
                long a = in.nextInt();
                long b = in.nextInt();
                long da = in.nextInt();
                long db = in.nextInt();

                if (solvable(numVertices, a, b, da, db, in, out)) {
                    out.println("Alice");
                } else {
                    out.println("Bob");
                }

            }
        }

        private boolean solvable(int numVertices, long a, long b, long da, long db, InputReader in, OutputWriter out) {

            UndirectedTree tree = new UndirectedTree(numVertices);

            for (int i = 0; i < numVertices - 1; i++) {
                tree.addEdge(in.nextInt(), in.nextInt());
            }

            if (db <= 2 * da) {
                return true;
            }

            if (tree.findDistance((int) a, (int) b) <= da) {
                return true;
            }

            if (tree.findDiameter() <= 2 * da) {
                return true;
            }

            return false;
        }

    }

    static class Node {
        int id;
        HashMap<Integer, Node> edges;

        public Node(int id) {
            this.id = id;
            edges = new HashMap<>();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class UndirectedTree {
        int size;
        HashMap<Integer, Node> nodes;

        public UndirectedTree(int size) {
            this.size = size;
            nodes = new HashMap<>();
        }

        public void addEdge(int start, int end) {
            nodes.putIfAbsent(start, new Node(start));
            nodes.putIfAbsent(end, new Node(end));

            Node startNode = nodes.get(start);
            Node endNode = nodes.get(end);
            startNode.edges.putIfAbsent(end, endNode);
            endNode.edges.putIfAbsent(start, startNode);
        }

        public int findDistance(int start, int end) {
            Node currentNode = nodes.get(start);

            // bfs
            HashSet<Node> visited = new HashSet<>();
            Queue<Node> currWave = new LinkedList<>();
            Queue<Node> nextWave = new LinkedList<>();
            currWave.add(currentNode);

            int distance = 0;

            while (!currWave.isEmpty()) {
                while (!currWave.isEmpty()) {
                    Node node = currWave.poll();
                    if (node.id == end) {
                        return distance;
                    }

                    visited.add(node);
                    for (Node edge : node.edges.values()) {
                        if (!visited.contains(edge)) {
                            nextWave.add(edge);
                        }
                    }
                }
                distance++;
                currWave = nextWave;
                nextWave = new LinkedList<>();
            }
            return -1;
        }

        public int findDiameter() {
            Node startNode = nodes.values().iterator().next();
            return recurse(startNode, new HashSet<>()).maxDiameter;
        }

        private Tuple recurse(Node n, Set<Node> visited) {
            if (visited.contains(n)) {
                return null;
            }

            int maxDiameter = 0;
            PriorityQueue<Integer> heights = new PriorityQueue<>();
            visited.add(n);
            for (Node edge : n.edges.values()) {
                Tuple t = recurse(edge, visited);
                if (t == null) {
                    continue;
                }
                maxDiameter = Math.max(maxDiameter, t.maxDiameter);
                heights.add(t.height + 1);
                if (heights.size() > 2) {
                    heights.poll();
                }
            }

            int secondHeight;
            int topHeight;
            if (!heights.isEmpty()) {
                secondHeight = heights.poll();
            } else {
                secondHeight = 0;
            }

            if (!heights.isEmpty()) {
                topHeight = heights.poll();
            } else {
                topHeight = secondHeight;
                secondHeight = 0;
            }

            maxDiameter = Math.max(maxDiameter, topHeight + secondHeight);
            visited.remove(n);
            return new Tuple(topHeight, maxDiameter);
        }

        class Tuple {
            int height;
            int maxDiameter;

            public Tuple(int height, int maxDiameter) {
                this.height = height;
                this.maxDiameter = maxDiameter;
            }

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }
}


import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.text.DecimalFormat;
public class Mamo {
    static long mod=998244353L;
    static Reader in=new Reader();
    static List<Integer >G[];
    public static xtree STree;
    static StringBuilder Sd=new StringBuilder(),Sl=new StringBuilder();
    public static void main(String [] args) throws IOException {
    	//Dir by MohammedElkady
    	int t=in.nextInt();
        	while(t-->0) {
        	int n=in.nextInt();
        	int a=in.nextInt(),b=in.nextInt(),da=in.nextInt(),db=in.nextInt();
        	G=new List[n+2];
        	for(int i=0;i<n+2;i++)G[i]=new ArrayList<Integer>();
        	for(int i=0;i<n-1;i++) {int u=in.nextInt(),v=in.nextInt();G[u].add(v);G[v].add(u);}
        	if(da*2>db) {out.append("Alice \n");}
        	else {
        		pok=new LinkedList();
            	boolean []visit=new boolean [n+1];
            	db=da*2;
            	if(G[a].size()==1)
            		a=G[a].get(0);
            	pok.add(a);
            	pok.add(-1);
            	int pos=0;
            	while(!pok.isEmpty()) {
            		int x=pok.remove();

            		if(x==-1) {pos++;pok.add(-1);x=pok.remove();}
            		if(x==-1||x==b) {break;}
            		visit[x]=true;
            		for(int i:G[x]) {if(!visit[i])pok.add(i);}
            	}
            	if(pos<=da) {out.append("Alice \n");}else {
            		pok=new LinkedList();
                	 visit=new boolean [n+1];
                	pok.add(b);
                	pok.add(-1);
                    pos=0;
                    int l=b;
                	while(!pok.isEmpty()) {
                		int x=pok.remove();

                		if(x==-1) {pos++;pok.add(-1);x=pok.remove();}
                		if(x==-1) {break;}
                		l=x;
                		visit[x]=true;
                		for(int i:G[x]) {if(!visit[i]) {pok.add(i);}

                		}
                	}
                	pok=new LinkedList();
               	 visit=new boolean [n+1];
               	pok.add(l);
               	pok.add(-1);
                pos=-1;
                while(!pok.isEmpty()) {
            		int x=pok.remove();
            		if(x==-1) {pos++;pok.add(-1);x=pok.remove();}
            		if(x==-1) {break;}
            		visit[x]=true;
            		for(int i:G[x]) {if(!visit[i]) {pok.add(i);}

            		}
            	}
                if(pos>=db) {out.append("Bob\n");}else out.append("Alice \n");
            	}
        	}
        	}

 out.close();
    }
    static void dfs() {

    }
    static BigInteger mode[]=new BigInteger[300011];

    static long ans=0L;
    static boolean v[];
    static ArrayList<Integer>res;
    static  Queue <Integer> pok=new LinkedList();
    static  Stack <Integer>rem[];
    public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
    static long gcd(long g,long x){if(x<1)return g;else return gcd(x,g%x);}
    static class Reader
    {
        private InputStream mIs;private byte[] buf = new byte[1024];private int curChar,numChars;public Reader() { this(System.in); }public Reader(InputStream is) { mIs = is;}
        public int read() {if (numChars == -1) throw new InputMismatchException();if (curChar >= numChars) {curChar = 0;try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}if (numChars <= 0) return -1; }return buf[curChar++];}
        public String nextLine(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isEndOfLine(c));return res.toString() ;}
        public String s(){int c = read();while (isSpaceChar(c)) c = read();StringBuilder res = new StringBuilder();do {res.appendCodePoint(c);c = read();}while (!isSpaceChar(c));return res.toString();}
        public long l(){int c = read();while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }long res = 0; do{ if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read();}while(!isSpaceChar(c));return res * sgn;}
        public int nextInt(){int c = read() ;while (isSpaceChar(c)) c = read();int sgn = 1;if (c == '-') { sgn = -1 ; c = read() ; }int res = 0;do{if (c < '0' || c > '9') throw new InputMismatchException();res *= 10 ; res += c - '0' ; c = read() ;}while(!isSpaceChar(c));return res * sgn;}
        public double d() throws IOException {return Double.parseDouble(s()) ;}
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
        public int[] arr(int n){int[] ret = new int[n];for (int i = 0; i < n; i++) {ret[i] = nextInt();}return ret;}
    }
}
class node implements Comparable<node> {

int hap,te;
node(int ll,int end){
hap=ll;
this.te=end;
}

@Override
public int compareTo(node o) {
	// TODO Auto-generated method stub
	if(hap!=o.hap)
	return hap-o.hap;
	else
		return te;
}
}
class xtree{
	public xtree(int n,int a[]) {
		this.a=a;
		seg=new int[n*4];
		//lazy=new int[n*4];
		build(1,0,n-1);
	}
	int seg[], a[],lazy[];
	    void check(int p,int s,int e) {
	        if(lazy[p]!=0) {
	            seg[p] += lazy[p];
	            if(s!=e) {
	                lazy[2*p] += lazy[p];
	                lazy[2*p+1] += lazy[p];
	            }
	            lazy[p] = 0;
	        }
	    }

	     void build(int p,int s,int e) {
	        //check(p,s,e);

	        if(s==e) {
	            seg[p] = a[s];
	            return;
	        }

	        build(2*p,s,(s+e)/2);
	        build(2*p+1,(s+e)/2+1,e);

	        seg[p] = seg[2*p]+ seg[2*p+1];
	    }

	   void update(int p,int s,int e,int i,int v) {
	       // check(p,s,e);

	        if(s==e) {
	            seg[p] = v;
	            return;
	        }

	        if(i<=(s+e)/2) update(2*p,s,(s+e)/2,i,v);
	        else update(2*p+1,(s+e)/2+1,e,i,v);

	        seg[p] = seg[2*p]+seg[2*p+1];
	    }

	     void update(int p,int s,int e,int a,int b,int v) {
	        //check(p,s,e);

	        if(s>=a && e<=b) {
	            seg[p] += v;

	            if(s!=e) {
	                lazy[2*p] += v;
	                lazy[2*p+1] += v;
	            }

	            return;
	        }

	        if(s>b || e<a)
	            return;

	        update(2*p,s,(s+e)/2,a,b,v);
	        update(2*p+1,(s+e)/2+1,e,a,b,v);

	        seg[p] = seg[2*p]+seg[2*p+1];
	    }

    int get(int p,int s,int e,int a,int b) {
        if(s>=a && e<=b)
            return seg[p];

        if(s>b || e<a)
            return 0;

        return get(2*p,s,(s+e)/2,a,b)+ get(2*p+1,(s+e)/2+1,e,a,b);
    }
}

class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
}

class Sorting{

 public static long[] bucketSort(long[] array, int bucketCount) {

 if (bucketCount <= 0) throw new IllegalArgumentException("Invalid bucket count");

 if (array.length <= 1) return array; //trivially sorted

 long high = array[0];

 long low = array[0];

 for (int i = 1; i < array.length; i++) { //find the range of input elements

 if (array[i] > high) high = array[i];

 if (array[i] < low) low = array[i];

 }

 double interval = ((double)(high - low + 1))/bucketCount; //range of one bucket

 ArrayList<Long> buckets[] = new ArrayList[bucketCount];

 for (int i = 0; i < bucketCount; i++) { //initialize buckets

 buckets[i] = new ArrayList();

 }

 for (int i = 0; i < array.length; i++) { //partition the input array

 buckets[(int)((array[i] - low)/interval)].add(array[i]);

 }

 int pointer = 0;

 for (int i = 0; i < buckets.length; i++) {

 Collections.sort(buckets[i]); //mergeSort

 for (int j = 0; j < buckets[i].size(); j++) { //merge the buckets

 array[pointer] = buckets[i].get(j);

 pointer++;

 }

}

return array;

}
}


import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.io.*;

public class c2 {
	static ArrayList<Integer>[] adj;
	static int max;
	public static void main(String[] args) throws NumberFormatException, IOException, InterruptedException {
		Scanner sc = new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
		int t=sc.nextInt();
		while(t-->0) {
			int n=sc.nextInt();
			adj=new ArrayList[n];
			for (int i = 0; i < adj.length; i++) {
				adj[i]=new ArrayList<Integer>();
			}
			int a=sc.nextInt();
			int b=sc.nextInt();
			int da=sc.nextInt();
			int db=sc.nextInt();

			for (int i = 0; i < n-1; i++) {
				int u=sc.nextInt()-1;
				int v=sc.nextInt()-1;
				adj[u].add(v);
				adj[v].add(u);
			}
			visited =new boolean [n];
			max=-1;
			dfs2(a-1,b-1,0);
			//System.out.println(max);
			if(da>=max) {
				System.out.println("Alice");
				continue;
			}
			max=-1;
			visited =new boolean [n];
			dfs(0,0);
			max=-1;
			visited =new boolean [n];
			dfs(fn,0);
			int diameter=max;
			if(2*da>=diameter) {
				System.out.println("Alice");
			}else if(db>2*da){
				System.out.println("Bob");
			}else {
				System.out.println("Alice");
			}

		}
		pw.close();
	}
	private static void dfs2(int a, int b,int c) {
		visited[a]=true;
		if(max!=-1)
			return;
		if(a==b) {
			max=c;
			return;
		}
		for (Integer x : adj[a]) {
			if(!visited[x]) {
				dfs2(x,b,c+1);
			}
		}
	}
	static boolean []visited;
	static int fn;
	private static void dfs(int i,int d) {
		visited[i]=true;
		if(d>max) {
			max=d;
			fn=i;
		}
		for (Integer x : adj[i]) {
			if(!visited[x]) {
				dfs(x,d+1);
			}
		}

	}

	static void shuffleArray(int[] ar) {
		// If running on Java 6 or older, use `new Random()` on RHS here
		Random rnd = ThreadLocalRandom.current();
		for (int i = ar.length - 1; i > 0; i--) {
			int index = rnd.nextInt(i + 1);
			// Simple swap
			int a = ar[index];
			ar[index] = ar[i];
			ar[i] = a;
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}

		public Scanner(FileReader r) {
			br = new BufferedReader(r);
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}

		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		public int[] nextIntArr(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < arr.length; i++)
				arr[i] = nextInt();
			return arr;
		}

		public boolean ready() throws IOException {
			return br.ready();
		}
	}

}


import java.util.*;
import java.lang.*;
import java.io.*;
import java.math.*;
public class Prac{
    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        public InputReader(InputStream st) {
            this.stream = st;
        }
        public int read() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int ni() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public long nl() {
            int c = read();
            while (isSpaceChar(c)) {
            c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public int[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public int[] nia1(int n) {
            int a[] = new int[n+1];
            for (int i = 1; i <=n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public long[] nla(int n) {
            long a[] = new long[n];
            for (int i = 0; i < n; i++) {
                a[i] = nl();
            }
            return a;
        }
        public long[] nla1(int n) {
            long a[] = new long[n+1];
            for (int i = 1; i <= n; i++) {
                a[i] = nl();
            }
            return a;
        }
        public Long[] nLa(int n) {
            Long a[] = new Long[n];
            for (int i = 0; i < n; i++) {
                a[i] = nl();
            }
            return a;
        }
        public Long[] nLa1(int n) {
            Long a[] = new Long[n+1];
            for (int i = 1; i <= n; i++) {
                a[i] = nl();
            }
            return a;
        }
        public Integer[] nIa(int n) {
            Integer a[] = new Integer[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public Integer[] nIa1(int n) {
            Integer a[] = new Integer[n+1];
            for (int i = 1; i <= n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public String rs() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                    c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
        public String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }
        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
    }
    public static class Key {
        private final int x, y;
        public Key(int x, int y) {
            this.x = x; this.y = y;
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }
        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }
    }
    static class Pair implements Comparable<Pair>{
            int x,y;
            Pair(int a,int b){
                    x=a;y=b;
            }
            @Override
            public int compareTo(Pair p) {
                    if(x==p.x) return y-p.y;
                    return x-p.x;
            }
    }
    static void shuffleArray(long temp[]){
        int n = temp.length;
        Random rnd = new Random();
        for(int i=0; i<n; ++i){
            long tmp = temp[i];
            int randomPos = i + rnd.nextInt(n-i);
            temp[i] = temp[randomPos];
            temp[randomPos] = tmp;
        }
    }
    static long gcd(long a,long b){ return b==0?a:gcd(b,a%b);}
    static long lcm(long a,long b){return (a/gcd(a,b))*b;}
    static PrintWriter w = new PrintWriter(System.out);
    static long mod1=998244353L,mod=1000000007;
    //static int r[]={0,1,0,-1}, c[]={1,0,-1,0};
    static ArrayList<Integer> arr[];
    static int dist , dia;
    static void dfs(int i , int p , int d , int b){
        if(i == b){
            dist = d;
            return;
        }
        for(int j : arr[i]){
            if(j != p){
                dfs(j , i , d+1 , b);
            }
        }
    }
    static void find(int n){
        Queue<Integer> q = new LinkedList<>();
        int ver = 1;
        boolean v [] = new boolean[n+1];
        q.add(1);
        while(!q.isEmpty()){
            int size = q.size();
            while(size -- > 0){
                ver = q.poll();
                if(v[ver])continue;
                v[ver] = true;
                for(int j : arr[ver]){
                    if(!v[j]){
                        q.add(j);

                    }
                }
            }
        }
        q.clear();
        q.add(ver);
        Arrays.fill(v , false);
        while(!q.isEmpty()){
            int size = q.size();
            while(size -- > 0){
                int x = q.poll();
                if(v[x]) continue;
                v[x] = true;
                for(int j : arr[x]){
                    if(!v[j]){
                        q.add(j );
                    }
                }
            }
            dia++;
        }
    }
    public static void main(String [] args){
        InputReader sc=new InputReader(System.in);
        int t=sc.ni();
        while(t-->0){
            int n = sc.ni();
            int a = sc.ni();
            int b = sc.ni();
            int da = sc.ni();
            int db = sc.ni();
            arr = new ArrayList[n+1];

            for(int i = 0 ; i <= n ; i++ ){
                arr[i] = new ArrayList<>();
            }
            for(int i=0;i<n-1;i++){
                int u = sc.ni();
                int v = sc.ni();
                arr[u].add(v);
                arr[v].add(u);
            }
            dist = 0;
            dfs(a , a , 0 , b);
            if(dist <= da){
                w.println("Alice");
            }
            else{
                dia = -1;
                find(n);
                if(2*da >= dia){
                    w.println("Alice");
                }
                else{
                    if(2*da < db)w.println("Bob");
                    else w.println("Alice");
                }
            }

        }
        w.close();
    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * @author khokharnikunj8
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "khokharnikunj8", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            DTreeTag solver = new DTreeTag();
            int testCount = Integer.parseInt(in.next());
            for (int i = 1; i <= testCount; i++)
                solver.solve(i, in, out);
            out.close();
        }
    }

    static class DTreeTag {
        int[][] G;
        int dist = -1;
        int dia = 0;
        int a;
        int b;

        public int dfs(int node, int parent, int depth) {
            int max1 = 0;
            int max2 = 0;
            if (node == b) dist = depth;
            for (int i : G[node]) {
                if (i == parent) continue;
                int child = dfs(i, node, depth + 1) + 1;
                if (child >= max1) {
                    max2 = max1;
                    max1 = child;
                } else if (max2 <= child) {
                    max2 = child;
                }
            }
            dia = Math.max(dia, max1 + max2);
            return Math.max(max1, max2);
        }

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.readInt();
            a = in.readInt();
            b = in.readInt();
            int da = in.readInt();
            int db = in.readInt();
            int[] from = new int[n - 1];
            int[] to = new int[n - 1];
            for (int i = 0; i < n - 1; i++) {
                from[i] = in.readInt();
                to[i] = in.readInt();
            }
            G = packGraph(from, to, n);
            dia = Math.max(dia, dfs(a, -1, 0));
            if (dist <= da) {
                out.println("Alice");
            } else if (da >= dia / 2 + (dia % 2)) {
                out.println("Alice");
            } else if (db > 2 * da) {
                out.println("Bob");
            } else {
                out.println("Alice");
            }
        }

        public int[][] packGraph(int[] from, int[] to, int n) {
            int[][] g = new int[n + 1][];
            int[] p = new int[n + 1];
            for (int i : from) p[i]++;
            for (int i : to) p[i]++;
            for (int i = 0; i <= n; i++) g[i] = new int[p[i]];
            for (int i = 0; i < from.length; i++) {
                g[from[i]][--p[from[i]]] = to[i];
                g[to[i]][--p[to[i]]] = from[i];
            }
            return g;
        }

    }

    static class FastInput {
        private final InputStream is;
        private final StringBuilder defaultStringBuf = new StringBuilder(1 << 13);
        private final byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public String next() {
            return readString();
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

        public String readString(StringBuilder builder) {
            skipBlank();

            while (next > 32) {
                builder.append((char) next);
                next = read();
            }

            return builder.toString();
        }

        public String readString() {
            defaultStringBuf.setLength(0);
            return readString(defaultStringBuf);
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private final Writer os;
        private final StringBuilder cache = new StringBuilder(5 << 20);

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        public FastOutput append(char c) {
            cache.append(c);
            return this;
        }

        public FastOutput append(String c) {
            cache.append(c);
            return this;
        }

        public FastOutput println(String c) {
            return append(c).println();
        }

        public FastOutput println() {
            cache.append(System.lineSeparator());
            return this;
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * @author khokharnikunj8
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "khokharnikunj8", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            DTreeTag solver = new DTreeTag();
            int testCount = Integer.parseInt(in.next());
            for (int i = 1; i <= testCount; i++)
                solver.solve(i, in, out);
            out.close();
        }
    }

    static class DTreeTag {
        int[][] G;
        int dist = -1;
        int dia = 0;
        int a;
        int b;

        public int dfs(int node, int parent, int depth) {
            int max1 = 0;
            int max2 = 0;
            if (node == b) dist = depth;
            for (int i : G[node]) {
                if (i == parent) continue;
                int child = dfs(i, node, depth + 1) + 1;
                if (child >= max1) {
                    max2 = max1;
                    max1 = child;
                } else if (max2 <= child) {
                    max2 = child;
                }
            }
            dia = Math.max(dia, max1 + max2);
            return Math.max(max1, max2);
        }

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.readInt();
            a = in.readInt();
            b = in.readInt();
            int da = in.readInt();
            int db = in.readInt();
            int[] from = new int[n - 1];
            int[] to = new int[n - 1];
            for (int i = 0; i < n - 1; i++) {
                from[i] = in.readInt();
                to[i] = in.readInt();
            }
            G = packGraph(from, to, n);
            dfs(a, -1, 0);
            if (dist <= da) {
                out.println("Alice");
            } else if (da >= dist / 2 + (dist % 2)) {
                out.println("Alice");
            } else if (db > 2 * da) {
                out.println("Bob");
            } else {
                out.println("Alice");
            }
        }

        public int[][] packGraph(int[] from, int[] to, int n) {
            int[][] g = new int[n + 1][];
            int[] p = new int[n + 1];
            for (int i : from) p[i]++;
            for (int i : to) p[i]++;
            for (int i = 0; i <= n; i++) g[i] = new int[p[i]];
            for (int i = 0; i < from.length; i++) {
                g[from[i]][--p[from[i]]] = to[i];
                g[to[i]][--p[to[i]]] = from[i];
            }
            return g;
        }

    }

    static class FastInput {
        private final InputStream is;
        private final StringBuilder defaultStringBuf = new StringBuilder(1 << 13);
        private final byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public String next() {
            return readString();
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

        public String readString(StringBuilder builder) {
            skipBlank();

            while (next > 32) {
                builder.append((char) next);
                next = read();
            }

            return builder.toString();
        }

        public String readString() {
            defaultStringBuf.setLength(0);
            return readString(defaultStringBuf);
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private final Writer os;
        private final StringBuilder cache = new StringBuilder(5 << 20);

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        public FastOutput append(char c) {
            cache.append(c);
            return this;
        }

        public FastOutput append(String c) {
            cache.append(c);
            return this;
        }

        public FastOutput println(String c) {
            return append(c).println();
        }

        public FastOutput println() {
            cache.append(System.lineSeparator());
            return this;
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * @author khokharnikunj8
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "khokharnikunj8", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            DTreeTag solver = new DTreeTag();
            int testCount = Integer.parseInt(in.next());
            for (int i = 1; i <= testCount; i++)
                solver.solve(i, in, out);
            out.close();
        }
    }

    static class DTreeTag {
        int[][] G;
        int dist = -1;
        int dia;
        int a;
        int b;

        public int dfs(int node, int parent, int depth) {
            int max1 = 0;
            int max2 = 0;
            if (node == b) dist = depth;
            for (int i : G[node]) {
                if (i == parent) continue;
                int child = dfs(i, node, depth + 1) + 1;
                if (child >= max1) {
                    max2 = max1;
                    max1 = child;
                } else if (max2 <= child) {
                    max2 = child;
                }
            }
            dia = Math.max(dia, max1 + max2);
            return Math.max(max1, max2);
        }

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.readInt();
            a = in.readInt();
            b = in.readInt();
            int da = in.readInt();
            int db = in.readInt();
            int[] from = new int[n - 1];
            int[] to = new int[n - 1];
            for (int i = 0; i < n - 1; i++) {
                from[i] = in.readInt();
                to[i] = in.readInt();
            }
            dia = 0;
            G = packGraph(from, to, n);
            dfs(a, -1, 0);

//        out.println((2 * da >= Math.min(dia, db) || dist <= da ? "Alice" : "Bob"));

            if (dist <= da) {
                out.println("Alice");
            } else if (2 * da >= dia) {
                out.println("Alice");
            } else if (db > 2 * da) {
                out.println("Bob");
            } else {
                out.println("Alice");
            }
        }

        public int[][] packGraph(int[] from, int[] to, int n) {
            int[][] g = new int[n + 1][];
            int[] p = new int[n + 1];
            for (int i : from) p[i]++;
            for (int i : to) p[i]++;
            for (int i = 0; i <= n; i++) g[i] = new int[p[i]];
            for (int i = 0; i < from.length; i++) {
                g[from[i]][--p[from[i]]] = to[i];
                g[to[i]][--p[to[i]]] = from[i];
            }
            return g;
        }

    }

    static class FastInput {
        private final InputStream is;
        private final StringBuilder defaultStringBuf = new StringBuilder(1 << 13);
        private final byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public String next() {
            return readString();
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

        public String readString(StringBuilder builder) {
            skipBlank();

            while (next > 32) {
                builder.append((char) next);
                next = read();
            }

            return builder.toString();
        }

        public String readString() {
            defaultStringBuf.setLength(0);
            return readString(defaultStringBuf);
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private final Writer os;
        private final StringBuilder cache = new StringBuilder(5 << 20);

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        public FastOutput append(char c) {
            cache.append(c);
            return this;
        }

        public FastOutput append(String c) {
            cache.append(c);
            return this;
        }

        public FastOutput println(String c) {
            return append(c).println();
        }

        public FastOutput println() {
            cache.append(System.lineSeparator());
            return this;
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * @author khokharnikunj8
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "khokharnikunj8", 1 << 29);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            DTreeTag solver = new DTreeTag();
            int testCount = Integer.parseInt(in.next());
            for (int i = 1; i <= testCount; i++)
                solver.solve(i, in, out);
            out.close();
        }
    }

    static class DTreeTag {
        int[][] G;
        int dist = -1;
        int dia = 0;
        int a;
        int b;

        public int dfs(int node, int parent, int depth) {
            int max1 = 0;
            int max2 = 0;
            if (node == b) dist = depth;
            for (int i : G[node]) {
                if (i == parent) continue;
                int child = dfs(i, node, depth + 1) + 1;
                if (child >= max1) {
                    max2 = max1;
                    max1 = child;
                } else if (max2 <= child) {
                    max2 = child;
                }
            }
            dia = Math.max(dia, max1 + max2);
            return Math.max(max1, max2);
        }

        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.readInt();
            a = in.readInt();
            b = in.readInt();
            int da = in.readInt();
            int db = in.readInt();
            int[] from = new int[n - 1];
            int[] to = new int[n - 1];
            for (int i = 0; i < n - 1; i++) {
                from[i] = in.readInt();
                to[i] = in.readInt();
            }
            G = packGraph(from, to, n);
            dia = Math.max(dia, dfs(a, -1, 0));
            if (dist <= da) {
                out.println("Alice");
            } else if (2 * da >= dia) {
                out.println("Alice");
            } else if (db > 2 * da) {
                out.println("Bob");
            } else {
                out.println("Alice");
            }
        }

        public int[][] packGraph(int[] from, int[] to, int n) {
            int[][] g = new int[n + 1][];
            int[] p = new int[n + 1];
            for (int i : from) p[i]++;
            for (int i : to) p[i]++;
            for (int i = 0; i <= n; i++) g[i] = new int[p[i]];
            for (int i = 0; i < from.length; i++) {
                g[from[i]][--p[from[i]]] = to[i];
                g[to[i]][--p[to[i]]] = from[i];
            }
            return g;
        }

    }

    static class FastInput {
        private final InputStream is;
        private final StringBuilder defaultStringBuf = new StringBuilder(1 << 13);
        private final byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public String next() {
            return readString();
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

        public String readString(StringBuilder builder) {
            skipBlank();

            while (next > 32) {
                builder.append((char) next);
                next = read();
            }

            return builder.toString();
        }

        public String readString() {
            defaultStringBuf.setLength(0);
            return readString(defaultStringBuf);
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private final Writer os;
        private final StringBuilder cache = new StringBuilder(5 << 20);

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        public FastOutput append(char c) {
            cache.append(c);
            return this;
        }

        public FastOutput append(String c) {
            cache.append(c);
            return this;
        }

        public FastOutput println(String c) {
            return append(c).println();
        }

        public FastOutput println() {
            cache.append(System.lineSeparator());
            return this;
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }
}


/**
* I'm sorry I was an idiot
*/
#include<iostream>
#define ll long long
#include<vector>
#include<algorithm>

using namespace std;

bool checkValid(vector<ll> &a){
	for(int i = 0; i < a.size();++i){
		if(i == 0){
			ll va1,va2;
			va1 = a[a.size()-1];
			va2 = a[i+1];
			if(a[i] >= va1+va2)
				return false;
		}
		else if(i == a.size()-1){
			ll va1,va2;
			va1 = a[a.size()-1];
			va2 = a[0];
			if(a[i] >= va1+va2)
				return false;
		}
		else{
			ll va1,va2;
			va1 = a[i-1];
			va2 = a[i+1];
			if(a[i] >= va1+va2)
				return false;
		}
	}
	return true;
}

int main(){
	int siz;
	cin >> siz;
	vector<ll> nums(siz);
	for(int i = 0; i < siz;++i){
		cin >> nums[i];
	}
	sort(nums.begin(),nums.end());
	if(checkValid(nums)){
		puts("YES");
		for(int i = 0; i < siz;++i){
			if(i == 0)
				cout << nums[i];
			else
				cout << " " << nums[i];
		}
		cout << endl;
	}
	else
		puts("NO");
	return 0;
}


/**
* I'm sorry I was an idiot
*/
#include<iostream>
#define ll long long
#include<vector>
#include<algorithm>

using namespace std;

bool checkValid(vector<ll> &a){
	for(int i = 0; i < a.size();++i){
		if(i == 0){
			ll va1,va2;
			va1 = a[a.size()-1];
			va2 = a[i+1];
			if(a[i] >= va1+va2)
				return false;
		}
		else if(i == a.size()-1){
			ll va1,va2;
			va1 = a[i-1];
			va2 = a[0];
			if(a[i] >= va1+va2)
				return false;
		}
		else{
			ll va1,va2;
			va1 = a[i-1];
			va2 = a[i+1];
			if(a[i] >= va1+va2)
				return false;
		}
	}
	return true;
}

int main(){
	int siz;
	cin >> siz;
	vector<ll> nums(siz);
	for(int i = 0; i < siz;++i){
		cin >> nums[i];
	}
	sort(nums.begin(),nums.end());
	if(checkValid(nums)){
		puts("YES");
		for(int i = 0; i < siz;++i){
			if(i == 0)
				cout << nums[i];
			else
				cout << " " << nums[i];
		}
		cout << endl;
	}
	else
		puts("NO");
	return 0;
}


#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main()
{
   int n;
   cin>>n;
   vector<int> v(n);
   for(int i=0;i<n;i++)
   cin>>v[i];
   sort(v.begin(),v.end());
   bool yes=0;
   if(v[0]+v[n-2]>v[n-1])
   {
      cout<<"YES"<<endl;
      for(int i=0;i<n;i++)
        {
            cout<<v[i]<<" ";
        }
        return 0;
   }
   for(int i=0;i<n-3;i+=2)
   {
       if(v[i]+v[i+2]>v[n-1])
       {
           yes=1;
           break;
       }
   }
   if(yes==0)
   {
       cout<<"NO"<<endl;
       return 0;
   }
   cout<<"YES"<<endl;
   for(int i=0;i<n-2;i++)
   {
       cout<<v[i]<<" ";
   }
   cout<<v[n-1]<<" "<<v[n-2];
}


#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main()
{
   int n;
   cin>>n;
   vector<int> v(n);
   for(int i=0;i<n;i++)
   cin>>v[i];
   sort(v.begin(),v.end());
   bool yes=0;
   if(v[n-1]>=(v[n-1]+v[n-2]))
   {
       cout<<"NO"<<endl;
       return 0;
   }
   else
   {
       cout<<"YES"<<endl;
       if(v[0]+v[n-2]>v[n-1])
       {
           for(int i=0;i<n;i++)
           cout<<v[i]<<" ";
       }
       else
       {
           for(int i=0;i<n-2;i++)
           cout<<v[i]<<" ";
           cout<<v[n-1]<<" "<<v[n-2];
       }
   }
}


#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main()
{
   int n;
   cin>>n;
   vector<int> v(n);
   for(int i=0;i<n;i++)
   cin>>v[i];
   sort(v.begin(),v.end());
   bool yes=0;
   if(v[0]+v[n-2]>v[n-1])
   {
      for(int i=0;i<n;i++)
        {
            cout<<v[i]<<" ";
        }
        return 0;
   }
   for(int i=0;i<n-3;i+=2)
   {
       if(v[i]+v[i+2]>v[n-1])
       {
           yes=1;
           break;
       }
   }
   if(yes==0)
   {
       cout<<"NO"<<endl;
       return 0;
   }
   cout<<"YES"<<endl;
   for(int i=0;i<n-2;i++)
   {
       cout<<v[i]<<" ";
   }
   cout<<v[n-1]<<" "<<v[n-2];
}


#include <bits/stdc++.h>
#include <iostream>

using namespace std;

int main()
{
   int n;
   cin>>n;
   vector<int> v(n);
   for(int i=0;i<n;i++)
   cin>>v[i];
   sort(v.begin(),v.end());
   bool yes=0;
   if(v[n-1]>=(v[n-2]+v[n-3]))
   {
       cout<<"NO"<<endl;
       return 0;
   }
   else
   {
       cout<<"YES"<<endl;
       if(v[0]+v[n-2]>v[n-1])
       {
           for(int i=0;i<n;i++)
           cout<<v[i]<<" ";
       }
       else
       {
           for(int i=0;i<n-2;i++)
           cout<<v[i]<<" ";
           cout<<v[n-1]<<" "<<v[n-2];
       }
   }
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    long long num;
    deque<long long> nums;
    deque<long long> anss;
    for(int i =0; i < n; i++)
    {
        cin >> num;
        nums.push_back(num);
    }
    sort(nums.begin(), nums.end());
    anss.push_back(nums.back());
    nums.pop_back();
    while(nums.size())
    {
        if(anss.front() >= anss.back())
        {
            anss.push_front(nums.back());
        }
        else
            anss.push_back(nums.back());
        nums.pop_back();
    }
    bool good =1;
    for(int i =0;i < n; i++)
    {
        if(i == 0 && anss[i] >= anss[n-1]+anss[1])
        {
            good = 0;
            break;
        }
        else if(i == n-1 && anss[i] >= anss[n-2]+anss[0])
        {
            good = 0;
            break;
        }
        else
        {
            if(anss[i] >= anss[i+1]+anss[i-1])
            {
                good = 0;
                break;
            }
        }
    }
    if(good)
    {
        cout << "YES" << endl;
        for(int i =0; i < n; i++)
            cout << anss[i] << " ";
    }
    else
        cout << "NO" << endl;
    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    long long arr[n];

    for(int i =0; i < n; i++)
    {
        cin >> arr[i];
    }
    sort(arr, arr+n);
    if(arr[n-1] >= arr[n-2]+arr[n-3])
        cout << "NO" << endl;
    else
    {
        cout << "YES" << endl;
        cout << arr[n-2] << " " << arr[n-1]<< " "<< arr[n-3] << " ";
        if(n >= 4)
        {
            for(int i = n-4; i >= 0; i--)
            {
                cout << arr[i] << " ";
            }
        }
    }

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    long long arr[n];
    for(int  i = 0; i < n; i++)
    {
        cin >> arr[i];
    }

    sort(arr, arr+n);
    bool good = 1;
    if(arr[n-1] >= (arr[0]+arr[n-2]))
        good = 0;
    if(arr[0] >= (arr[n-1]+arr[1]))
        good = 0;
    if(good)
    {
        for(int i = 1; i < n-1; i++)
        {
            if(arr[i] >= (arr[i-1]+arr[i+1]))
                good = 0;
        }
        if(good)
        {
            cout << "YES" << endl;
            for(int i=0;i < n; i++)
                cout << arr[i]<<" ";
        }
        else
            cout << "NO" << endl;
    }
    else
        cout << "NO" <<endl;

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    int arr[n];
    for(int  i =0; i < n; i++)
    {
        cin >> arr[i];
    }

    sort(arr, arr+n);
    bool good = 1;
    if(arr[n-1] >= arr[0]+arr[n-2])
        good = 0;
    if(arr[0] >= arr[n-1]+arr[1])
        good = 0;
    if(good)
    {
        for(int  i =1; i < n-1; i++)
        {
            if(arr[i] >= arr[i-1]+arr[i+1])
                good = 0;
        }
        if(good)
        {
            cout << "YES" << endl;
            for(int i=0;i < n; i++)
                cout << arr[i]<<" ";
        }
        else
            cout << "NO" << endl;
    }
    else
        cout << "NO" <<endl;

    return 0;
}


#include <bits/stdc++.h>
using namespace std;

int main()
{
    int n;
    cin >> n;
    long long num;
    deque<long long> nums;
    deque<long long> anss;
    for(int i =0; i < n; i++)
    {
        cin >> num;
        nums.push_back(num);
    }
    sort(nums.begin(), nums.end());
    bool frontt = 0;
    while(nums.size())
    {
        if(!frontt)
        {
            anss.push_back(nums[nums.size()-1]);
            frontt = 1;
        }
        else
        {
            anss.push_front(nums[nums.size()-1]);
            frontt = 0;
        }
        nums.pop_back();
    }
    bool good =1;
    for(int i =0;i < n; i++)
    {
        if(i == 0 && anss[i] >= anss[n-1]+anss[1])
        {
            good = 0;
            break;
        }
        else if(i == n-1 && anss[i] >= anss[n-2]+anss[0])
        {
            good = 0;
            break;
        }
        else
        {
            if(anss[i] >= anss[i+1]+anss[i-1])
            {
                good = 0;
                break;
            }
        }
    }
    if(good)
    {
        cout << "YES" << endl;
        for(int i =0; i < n; i++)
            cout << anss[i] << " ";
    }
    else
        cout << "NO" << endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<long, long> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef set<int> si;
typedef set<ll> sl;
typedef vector<string> vs;

#define input(v,n) for(ll i=0;i<n;i++)cin>>v[i]
#define inputp(v,n) for(ll i=0;i<n;i++)cin>>v[i].first>>v[i].second
#define banao(x,y) memset(x,y,sizeof(x));
#define PI (2*acos(0.0))
#define pb push_back
#define show(v) for(int i = 0; i < v.size(); i++) cout << v[i] << " "; cout << endl;
#define showpair(v) for(int i = 0; i < v.size(); i++) cout << v[i].first << " " << v[i].second << endl;
#define ff first
#define ss second
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define forn(i,n) for(i=0;i<n;i++)
#define forr(i,e) for(i=e;i>=0;i--)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sortn(v) sort(all(v))
#define sortr(v) sort(rall(v))

int main()
{
    ll n,i;
    cin>>n;
    vll v(n);
    input(v,n);
    sortn(v);
    swap(v[n-1],v[n-2]);
    forn(i,n)
    {
        if(i==0)
        {
            if(v[n-1]+v[i+1]<=v[i])
            {
                cout<<"NO"<<endl;
                return 0;
            }
        }
        else
        {
            if(v[i-1]+v[i+1]<=v[i])
            {
                cout<<"NO"<<endl;
                return 0;
            }
        }
    }

    cout<<"YES"<<endl;
    show(v);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<long, long> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef set<int> si;
typedef set<ll> sl;
typedef vector<string> vs;

#define input(v,n) for(ll i=0;i<n;i++)cin>>v[i]
#define inputp(v,n) for(ll i=0;i<n;i++)cin>>v[i].first>>v[i].second
#define banao(x,y) memset(x,y,sizeof(x));
#define PI (2*acos(0.0))
#define pb push_back
#define show(v) for(int i = 0; i < v.size(); i++) cout << v[i] << " "; cout << endl;
#define showpair(v) for(int i = 0; i < v.size(); i++) cout << v[i].first << " " << v[i].second << endl;
#define ff first
#define ss second
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define forn(i,n) for(i=0;i<n;i++)
#define forr(i,e) for(i=e;i>=0;i--)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sortn(v) sort(all(v))
#define sortr(v) sort(rall(v))

int main()
{
   ll n,i;
   cin>>n;
   vll v(n);
   input(v,n);
   sortr(v);
   bool flag=false;
   forn(i,n)
   {
     if(i==0)
     {
         if(v[n-1]+v[i+1]<=v[i])
         {
             flag=true;
             break;
         }
     }
     else
     {
        if(v[i-1]+v[i+1]<=v[i])
         {
             flag=true;
             break;
         }
     }
   }
   if(flag==false)
   {
       cout<<"YES"<<endl;
       show(v);
   }
   else
    cout<<"NO"<<endl;

return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<long, long> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef set<int> si;
typedef set<ll> sl;
typedef vector<string> vs;

#define input(v,n) for(ll i=0;i<n;i++)cin>>v[i]
#define inputp(v,n) for(ll i=0;i<n;i++)cin>>v[i].first>>v[i].second
#define banao(x,y) memset(x,y,sizeof(x));
#define PI (2*acos(0.0))
#define pb push_back
#define show(v) for(int i = 0; i < v.size(); i++) cout << v[i] << " "; cout << endl;
#define showpair(v) for(int i = 0; i < v.size(); i++) cout << v[i].first << " " << v[i].second << endl;
#define ff first
#define ss second
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define forn(i,n) for(i=0;i<n;i++)
#define forr(i,e) for(i=e;i>=0;i--)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sortn(v) sort(all(v))
#define sortr(v) sort(rall(v))

int main()
{
    ll n,i;
    cin>>n;
    vll v(n);
    input(v,n);
    sortn(v);
    swap(v[n-1],v[n-2]);
    for(ll j=1; j<n; j++)
    {
        ll x=j+1;
        if(x==n)
            x=0;

        if(v[j-1]+v[x]<=v[i])
        {
            cout<<"NO"<<endl;
            return 0;
        }

    }

    cout<<"YES"<<endl;
    show(v);
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<long, long> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef set<int> si;
typedef set<ll> sl;
typedef vector<string> vs;

#define input(v,n) for(ll i=0;i<n;i++)cin>>v[i]
#define inputp(v,n) for(ll i=0;i<n;i++)cin>>v[i].first>>v[i].second
#define banao(x,y) memset(x,y,sizeof(x));
#define PI (2*acos(0.0))
#define pb push_back
#define show(v) for(int i = 0; i < v.size(); i++) cout << v[i] << " "; cout << endl;
#define showpair(v) for(int i = 0; i < v.size(); i++) cout << v[i].first << " " << v[i].second << endl;
#define ff first
#define ss second
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define forn(i,n) for(i=0;i<n;i++)
#define forr(i,e) for(i=e;i>=0;i--)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sortn(v) sort(all(v))
#define sortr(v) sort(rall(v))

int main()
{
    ll n,i;
    cin>>n;
    vll v(n);
    input(v,n);
    sortn(v);
    swap(v[n-1],v[n-2]);
    for(ll j=1; j<n; j++)
    {
        ll x=j+1;
        if(x==n)
            x=0;

        if(v[j-1]+v[x]<=v[j])
        {
            cout<<"NO"<<endl;
            return 0;
        }

    }

    cout<<"YES"<<endl;
    show(v);
    return 0;
}