#include <bits/stdc++.h>

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, start, a, b;
    std::cin >> n >> start >> a >> b;
    start--;
    std::vector<std::vector<int>> gr(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        std::cin >> u >> v;
        u--;
        v--;

        gr[u].push_back(v);
        gr[v].push_back(u);
    }

    if (a <= b) {
        std::cout << 1 << "\n";
        return 0;
    }

    std::vector<int> depth(n), height(n), prv(n);  //, max_sb(n);
    {
        auto dfs = [&](auto dfs, int v, int f) -> void {
            prv[v] = f;
            depth[v] = f == -1 ? 0 : depth[f] + 1;
            height[v] = 0;
            for (int& t : gr[v]) {
                if (t != f) {
                    dfs(dfs, t, v);
                    height[v] = std::max(height[v], height[t] + 1);
                } else {
                    t = -1;
                }
            }
            std::erase(gr[v], -1);
        };
        dfs(dfs, start, -1);
    }
    std::vector<int> ord(n);
    std::iota(ord.begin(), ord.end(), 0);
    std::sort(ord.begin(), ord.end(), [&](int a, int b) { return height[a] < height[b]; });

    // // dp1 - Alice, dp2 - Bob, dp3 - Alice restricted
    std::vector<int> dp1(n, -1), dp2(n, n);
    std::vector<std::vector<int>> dp3(n);

    for (int i = 0; i < n; i++) {
        dp3[i].assign(gr[i].size(), -1);
    }

    for (int i : ord) {
        int g = gr[i].size();
        {
            auto dfs0 = [&](auto dfs0, int v, int f, int d) -> int {
                if (d < 0) {
                    return n;
                }
                int val = v;
                for (int t : gr[v]) {
                    if (t != f) {
                        val = std::min(val, dfs0(dfs0, t, v, d - 1));
                    }
                }
                return val;
            };
            auto dfs1 = [&](auto dfs1, int v, int f, int d) -> int {
                if (d == 0) {
                    // return v;
                    return dp2[v];
                }
                int val = -1;
                for (int t : gr[v]) {
                    if (t != f) {
                        val = std::max(val, dfs1(dfs1, t, v, d - 1));
                    }
                }
                return val;
            };

            if (height[i] < a) {
                dp1[i] = dfs0(dfs0, i, prv[i], b);
            } else {
                dp1[i] = dfs1(dfs1, i, prv[i], a);
                assert(dp1[i] != -1);
            }
            for (int j = 0; j < g; j++) {
                int t = gr[i][j];
                dp3[i][j] = dfs1(dfs1, i, t, a);
                if (dp3[i][j] == -1) {
                    dp3[i][j] = dfs0(dfs0, i, t, b);
                }
            }
        }
        {
            auto dfs = [&](auto dfs, int v, int f, int d, int val) {
                if (d < 0) {
                    return;
                }
                dp2[v] = std::min(dp2[v], val);
                for (int t : gr[v]) {
                    if (t != f) {
                        dfs(dfs, t, v, d - 1, val);
                    }
                }
                if (prv[i] != -1 && prv[i] != f) {
                    dfs(dfs, prv[i], v, d - 1, val);
                }
            };
            dp2[i] = std::min(dp2[i], dp1[i]);
            if (prv[i] != -1)
                dfs(dfs, prv[i], i, b - 1, dp1[i]);
            for (int j = 0; j < g; j++) {
                int t = gr[i][j];
                dfs(dfs, t, i, b - 1, dp3[i][j]);
            }
        }
        if (clock() * 1.0 / CLOCKS_PER_SEC > 1.0) {
            std::cout << i << " " << g << "\n";
            exit(1);
        }
    }

    std::cout << dp1[start] + 1 << "\n";

    return 0;
}