#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 inf=1e9;
const int MAXN=3e5+50;
vector<int> e[MAXN],su[MAXN];int n,Root,A,B;
int dep[MAXN],rv[MAXN],dfn[MAXN],siz[MAXN],par[MAXN];

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

//now:already O(nlogn)
namespace part0 {
    int fmx[MAXN],fmx2[MAXN];
    int stk[MAXN];
    void dfs0(int u,int fa) {
        par[u]=fa;dep[u]=dep[fa]+1;
        siz[u]=1;rv[dfn[u]=++dfn[0]]=u;
        fmx[u]=0;stk[dep[u]]=u;
        if(dep[u]-(A-1)>1) {
            su[stk[dep[u]-(A-1)]].pb(u);
        } 
        for(int v:e[u]) if(v!=fa) {
            dfs0(v,u);siz[u]+=siz[v];
            chkmax(fmx[u],fmx[v]+1);
        }
        int mx=0;
        for(auto v:e[u]) if(v!=fa) {
            chkmax(fmx2[v],mx);
            chkmax(mx,fmx[v]+1);
        }
        reverse(e[u].begin(),e[u].end());
        mx=0;
        for(auto v:e[u]) if(v!=fa) {
            chkmax(fmx2[v],mx);
            chkmax(mx,fmx[v]+1);
        }
        return ;
    };
    void init() {
        dfs0(Root,0);
    }
};
using part0::fmx;
using part0::fmx2;
bool in(int v,int u) {
    return dfn[v]>=dfn[u]&&dfn[v]<=dfn[u]+siz[u]-1;
}

vector<int> perm;
int f[MAXN],g[MAXN],ex[MAXN],ymp[MAXN];//f,g,ex:={0,1}
int F[MAXN];//nearest f: f=0
int Fsm[MAXN];//nearset 0

int lim;
void get_ex(int u) {
    
    for(auto son:e[u]) if(fmx2[son]>=A) ex[son]=0;
    else {
        // cerr<<son<<",";
        ex[son]=1;
    }
    int pr[2]={u>=lim,0},sf[2]={u>=lim,0};
    reverse(e[u].begin(),e[u].end());

    for(auto son:e[u]) {
        if(fmx2[son]>=A) {//alice move:big
            ex[son]|=pr[1];
        }
        else {//bob:small
            ex[son]&=pr[0];
        }
        for(auto v:su[son]) pr[1]|=g[v];
        // pr[0]&=(small[son]>=lim);
        pr[0]&=(Fsm[son]+1>B);
    }
    reverse(e[u].begin(),e[u].end());
    for(auto son:e[u]) {
        if(fmx2[son]>=A) {//alice move:big
            ex[son]|=sf[1];
        }
        else {//bob:small
            ex[son]&=sf[0];
        }
        for(auto v:su[son]) sf[1]|=g[v];
        // sf[0]&=(small[son]>=lim);
        sf[0]&=(Fsm[son]+1>B);
    }
}

void get_g(int u) {//O(n)
    if(F[u]<=B) {
        g[u]=0;return ;
    }
    // 
    g[u]=1;
    
    for(int y=u;y!=Root;y=par[y]) {
        for(auto v:e[par[y]]) if(!in(u,v)) {//not anc
            if(F[v]+(dep[u]-dep[y]+2)<=B) {
                g[u]=0;return ;
            }
        }
    }
    
    for(int y=u;y!=Root&&dep[u]-dep[y]<=B-1;y=par[y]) {
        if(!ex[y]) {
            g[u]=0;return ;
        }
    }
}
void upd_f(int u) {
    if(!f[u]) F[u]=0;
    else {
        F[u]=1e9;
        for(auto v:e[u]) chkmin(F[u],F[v]+1);
    } 
}

bool solution(int Lim) {
    lim=Lim;
    for(auto u:perm) {
        Fsm[u]=(u>=Lim)?inf:0;
        for(auto son:e[u]) {
            chkmin(Fsm[u],Fsm[son]+1);
        }
    }

    for(auto u:perm) {
        if(fmx[u]<A) {
            f[u]=(Fsm[u]>B);
        }
        else {
            f[u]=0;
            for(auto son:e[u]) {
                for(auto v:su[son]) {
                    // cerr<<son<<","<<v<<"\n";
                    // printf("[*]\n\n\n\n\n");
                    get_g(v);
                    f[u]|=g[v];
                }
            }
        }
        get_ex(u);
        upd_f(u);
    }  
    // for(int i=1;i<=n;++i) {
    //     printf("[%d,%d,%d,%d]%d\n",f[i],g[i],ex[i],F[i],Fsm[i]);
    // }
    return f[Root];
}

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);
        e[u].pb(v);
        e[v].pb(u);
    }
    part0::init() ;
    for(int u=1;u<=n;++u) {
        for(auto it=e[u].begin();it!=e[u].end();++it) if(dep[*it]==dep[u]-1) {
            e[u].erase(it);break;
        }
    }
    perm.clear();
    for(int u=1;u<=n;++u) perm.pb(u);
    sort(perm.begin(),perm.end(),[&] (auto i,auto j){return dep[i]>dep[j];});

    // printf("[%d]",solution(5));
    int l=1,r=n;
    while(l<r) {
        int mid=(l+r+1)>>1;
        if(solution(mid)) l=mid;
        else r=mid-1;
    }
    printf("%d",l);
    return ;
}

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