#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 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) {
                std::vector<int> vec(g);
                dp1[i] = dfs0(dfs0, i, prv[i], b);
                for (int j = 0; j < g; j++) {
                    int t = gr[i][j];
                    vec[j] = std::min(i, dfs0(dfs0, t, i, b - 1));
                }
                std::array<int, 2> min = {n, n};
                for (int j = 0; j < g; j++) {
                    min[1] = std::min(min[1], vec[j]);
                    std::sort(min.begin(), min.end());
                }
                for (int j = 0; j < g; j++) {
                    int val = vec[j] == min[0] ? min[1] : min[0];
                    dp3[i][j] = val;
                }
            } else {
                dp1[i] = dfs1(dfs1, i, -1, a);
                int h1 = -1, h2 = -1;
                for (int j = 0; j < g; j++) {
                    int t = gr[i][j];
                    if (height[t] + 1 >= a) {
                        (h1 == -1 ? h1 : h2) = j;
                    }
                }
                if (h2 == -1) {
                    assert(h1 != -1);
                    // assert(false);
                    dp3[i][h1] = dfs0(dfs0, i, gr[i][h1], b);
                    int val = dfs1(dfs1, gr[i][h1], i, a - 1);
                    for (int j = 0; j < g; j++) {
                        if (j != h1) {
                            dp3[i][j] = val;
                        }
                    }
                } else {
                    std::vector<int> vec(g);
                    for (int j = 0; j < g; j++) {
                        int t = gr[i][j];
                        vec[j] = dfs1(dfs1, t, i, a - 1);
                    }
                    std::array<int, 2> max = {-1, -1};
                    for (int j = 0; j < g; j++) {
                        max[1] = std::max(max[1], vec[j]);
                        std::sort(max.rbegin(), max.rend());
                    }
                    for (int j = 0; j < g; j++) {
                        int val = vec[j] == max[0] ? max[1] : max[0];
                        dp3[i][j] = val;
                    }
                }
            }
        }
        {
            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[v] != -1 && prv[v] != f) {
                    dfs(dfs, prv[v], 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]);
            }
        }
    }

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

    return 0;
}