#include<bits/stdc++.h>
using namespace std;
template<class T> void chkmin(T &x,T y) {x=(y<x)?y:x;}
template<class T> void chkmax(T &x,T y) {x=(y>x)?y:x;}
#define pb emplace_back
#define LOCAL 0
#define open_file if(LOCAL) {freopen("a.in","r",stdin);freopen("a.out","w",stdout);}
const int MAXN=3e5+50;
int Ex[MAXN],Dp[MAXN];// Dp:(u->v:u) Ex:(u->all-{v'}:v')
int Fb[MAXN];
vector<int> g[MAXN],e[MAXN];int n,Root,A,B;
int dep[MAXN],rv[MAXN],dfn[MAXN],siz[MAXN],par[MAXN],son[MAXN],top[MAXN];

#define bro(v,u) for(int v:g[par[u]]) if(v!=u)

namespace part0 {  //(1) get edges (2) initalize Dp,Ex
    int stk[MAXN],fmx[MAXN],fmx2[MAXN];
    void dfs1(int u,int fa) {
        par[u]=fa;dep[u]=dep[fa]+1;
        siz[u]=1;
        stk[dep[u]]=u;
        if(dep[u]-1>=A) {
            // e[stk[dep[u]]-(A-1)].pb(u);
            e[ stk[dep[u]-(A-1)] ].pb(u);
        }

        fmx[u]=0;
        for(int v:g[u]) if(v!=fa) {
            dfs1(v,u);siz[u]+=siz[v];
            chkmax(fmx[u],fmx[v]+1);
            if(siz[v]>siz[son[u]]) son[u]=v;
        }

    }
    void dfs2(int u,int fa) {
        rv[dfn[u]=++dfn[0]]=u;
        top[u]=(son[fa]==u)?top[fa]:u;
        if(son[u]) dfs2(son[u],u);
        for(int v:g[u]) if(v!=fa&&v!=son[u]) {
            dfs2(v,u);
        }
    }
    namespace dsu {
        int fa[MAXN];
        int get_fa(int x) {return (fa[x]==x)?x:(fa[x]=get_fa(fa[x]));}
        int del(int x) {
            // assert(x!=Root);
            fa[x]=par[x];
            return get_fa(x);
        }
        void init() {
            for(int i=1;i<=n;++i) fa[i]=i;
        }
    };

    void work() {
        dfs1(Root,0);
        dfs2(Root,0);

        for(int u=1;u<=n;++u) {
            sort(g[u].begin(),g[u].end(),[&] (auto i,auto j){return dep[i]>dep[j];});
            if(dep[g[u].back()]<dep[u]) g[u].pop_back();
        }

        for(int u=1;u<=n;++u) 
            bro(v,u) chkmax(fmx2[u],fmx[v]+1);

        // for(int u=1;u<=n;++u) {
            // printf("[%d]",dep[u]);
            // for(auto v:g[u]) printf("%d,",dep[v]);puts("");
        // }
        
        dsu::init();
        for(int i=1;i<=n;++i) {
            // cerr<<i<<"\n";
            if(!Dp[i]&&fmx[i]<A) Dp[i]=i;
            for(int v:g[i]) if(!Ex[v]&&fmx2[v]<A) Ex[v]=i;

            for(int u=dsu::get_fa(i);u!=Root&&dep[i]-dep[par[u]]<=B;u=dsu::del(u)) {//it's B's turn
                bro(v,u) if(!Ex[v]&&fmx2[v]<A) Ex[v]=i;//bf heres
                if(!Dp[par[u]]&&fmx[par[u]]<A) Dp[par[u]]=i; 
                // cerr<<u<<"\n";
            }
        }


        for(int i=1;i<=n;++i) if(i!=Root&&fmx2[i]<A) {
            assert(Ex[i]);
        }
    }
};
using part0::fmx;
using part0::fmx2;
namespace part1 {
    #define For(v,u) for(int my_id=dfn[u],v=rv[my_id];my_id<=dfn[u]+siz[u]-1;++my_id,v=rv[my_id])
    void get_g(int u) {
        For(v,u) if(dep[v]-dep[u]<=B) chkmin(Fb[u],Dp[v]);
        // if(u==1) {
        //     printf("[%d]\n",dep[u]-dep[par[par[u]]]<=B);
        // }
        for(int y=u;(y!=Root)&&(dep[u]-dep[par[y]]<=B);y=par[y]) {
            // if(u==1) printf("*%d*\n",y);
            chkmin(Fb[u],Ex[y]);
            bro(v,u)    
                For(c,v) if(dep[c]+dep[u]-2*dep[par[y]]<=B)//!!
                    chkmin(Fb[u],Dp[c]);
        }
    } 
};
using part1::get_g ;

void gen() {
    scanf("%d%d%d%d",&n,&Root,&A,&B);
    if(A<=B) {
        puts("1");return ;
    }
    for(int i=1,u,v;i<n;++i) {
        scanf("%d%d",&u,&v);
        g[u].pb(v);
        g[v].pb(u);
    }
    for(int i=1;i<=n;++i) {
        Fb[i]=n+1;
        Dp[i]=Ex[i]=0;
    }

    part0::work();

    // return ;

    // printf("{%d}\n",Ex[1]);

    // return ;
    vector<int> perm;
    for(int i=1;i<=n;++i) perm.pb(i);
    sort(perm.begin(),perm.end(),[&] (auto i,auto j){return dep[i]>dep[j];});
    for(auto rt:perm) {
        if(fmx[rt]<A) continue;
        for(auto u:g[rt]) {
            if(fmx[u]<A-1) continue;
            int res=0;
            for(auto v:e[u]) {
                get_g(v);//the most hard one
                chkmax(res,Fb[v]);
            }
            chkmax(Dp[rt],res);
            bro(v,u) chkmax(Ex[v],res);
        }
    }

    // for(int i=1;i<=n;++i) printf("[%d,%d,%d]\n",Dp[i],Fb[i],Ex[i]);
    // printf("{%d}",Fb[1]);

    int ans=Dp[Root];
    printf("%d",ans);
}

int main() {
    open_file 
    gen() ;
    return 0;
}