// Hydro submission #67a362f83e10c2b51029cc5c@1738760953628


#include<bits/stdc++.h>

using namespace std;

#define maxn 600005
// #define int long long
#define inf 1000000000

int _n,_rt,A,B,_siz[maxn],_deep[maxn],_dfn[maxn],_ed[maxn],_cnt[maxn];
int _ms[maxn],_top,_maxdp,_find[maxn],_toA[maxn],_toAA[maxn],_tt;
int _hmin[maxn],_mind[maxn],_minda[maxn],_num[maxn],_f[maxn],_h[maxn],_dp[maxn];
vector<int> _rd[maxn],_son[maxn],_have[maxn];

void cmax(int &a,int b){
    a=max(a,b);
}
void cmin(int &a,int b){
    a=min(a,b);
}

struct pp{
    int l,r,w,lz;
}_tree[maxn*4];

void push(int k,int w){
    cmax(_tree[k].w,w);
    cmax(_tree[k].lz,w);
}

void build(int k,int l,int r){//!!!
    _tree[k]={l,r,-inf,-inf};
    if(l==r)return;
    int mid = (l+r)>>1;
    build(k*2,l,mid);
    build(k*2+1,mid+1,r);
}

void down(int k){
    if(_tree[k].lz!=-1e9){
        push(k*2,_tree[k].lz);
        push(k*2+1,_tree[k].lz);
        _tree[k].lz=-1e9;
    }
}

void cg(int k,int L,int R,int w){
    if(L<=_tree[k].l&&_tree[k].r<=R){
        push(k,w);
        return;
    }
    down(k);
    if(_tree[k*2].r>=L)cg(k*2,L,R,w);
    if(_tree[k*2].r <R)cg(k*2+1,L,R,w);
}

int qr(int k,int x){
    if(_tree[k].l==_tree[k].r){
        return _tree[k].w;
    }
    down(k);
    if(_tree[k*2].r>=x)return qr(k*2,x);
    else return qr(k*2+1,x);
}
void dfs(int now,int fa){
    vector<int> sv;
    _deep[now]=_deep[fa]+1;
    _have[_deep[now]].push_back(now);
    cmax(_maxdp,_deep[now]);
    _dfn[now]=++_tt;
    _find[_tt]=now;
    _ms[++_top]=now;
    if(_top>A)_son[_toA[now]=_ms[_top-A]].push_back(now),_toAA[now]=_ms[_top-A+1];
    for(int v:_rd[now]){
        if(v==fa)continue;
        sv.push_back(v);
        dfs(v,now);
    }
    _rd[now].swap(sv);
    _ed[now]=_tt;
    _top--;
}


void clr(){
    for(int i = 1;i <= _n;i++){
        _f[i]=_dp[i]=_h[i]=_cnt[i]=_num[i]=0;
        _mind[i]=_hmin[i]=_minda[i]=inf;
    }
}

int check(int mid){
    build(1,1,_n);
    clr();
    for(int d = _maxdp;d >= 1;d--){
        if(d+A-B+1<=_maxdp){
            for(int u:_have[d+A-B+1]){
                if(!_h[u])cg(1,_dfn[u],_ed[u],1e9);
                else cg(1,_dfn[u],_ed[u],B+_deep[u]-_hmin[u]-1);
            }
        }
        if(d+A<=_maxdp){
            for(int u:_have[d+A]){
                if(_mind[u]<=B)_dp[u]=1;
                else if(!_dp[u]&&qr(1,_dfn[u])>=_deep[u])_dp[u]=1;
            }
        }
        for(int u:_have[d]){
            int sv1 = inf,sv2 =inf;
            for(int v:_rd[u]){
                int v1 = _minda[v]+1,v2=_mind[v]+1;
                if(v1<_minda[u])sv2=_minda[u],_minda[u]=v1;
                else cmin(sv2,v1);
                if(v2<_mind[u])sv1=_mind[u],_mind[u]=v2;
                else cmin(sv1,v2);
            }
            for(int v:_rd[u]){
                if(_mind[v]+1>_mind[u]){
                    _hmin[v]=_mind[u];
                }else{
                    _hmin[v]=sv1;
                }
            }
            if(u<mid)_minda[u]=0;
            if(_son[u].size()){
                for(int v:_son[u]){
                    _f[u]|=(_dp[v]^1);
                }
            }else{
                if(_minda[u]>B){
                    _f[u]=1;
                }else{
                    _f[u]=0;
                }
            }
            int sg = 0,all = 0;
            for(int v:_son[u]){
                int k = _toAA[v];
                _cnt[k]+=(_dp[v]^1);
                _num[k]++;all++;sg+=(_dp[v]^1);
            }
            for(int v:_rd[u]){
                if(all==_num[v]){
                    if((_minda[u]<=B&&_minda[u]!=_minda[v]+1)||sv2<=B||u<mid)_h[v]=0;
                    else _h[v]=1;
                }else{
                    _h[v]=(sg!=_cnt[v]);
                }
            }
            if(!_f[u])_mind[u]=0;
        }
    }
    return _f[_rt];
}

int _t;

signed main(){
    freopen("fruit.in","r",stdin);
    freopen("fruit.out","w",stdout);
    // cin >> _t;
    _t=1;
    while(_t--){
        cin >> _n >> _rt >> A >> B;
        _tt=0;
        for(int i = 1;i <= _maxdp;i++){
            _have[i].clear();
        }
        _maxdp=0;
        for(int i = 1;i <= _n;i++)_rd[i].clear(),_son[i].clear();
        for(int i = 1,a,b;i < _n;i++){
            cin >> a >> b;
            _rd[a].push_back(b);
            _rd[b].push_back(a);
        }
        if(A<=B){
            cout << 1 << endl;
            continue;
        }
        dfs(_rt,0);
        int l = 1,r = _n,mid,ans=1;
        while(l<=r){
            mid = (l+r)/2;
            if(check(mid)){
                l=mid+1;
                ans=mid;
            }else{
                r=mid-1;
            }
        }
        cout << ans << endl;
    }
    return 0;
}

answer.code: In function ‘void build(int, int, int)’:
answer.code:34:28: warning: extended initializer lists only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
   34 |     _tree[k]={l,r,-inf,-inf};
      |                            ^
answer.code:34:28: warning: extended initializer lists only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
answer.code: In function ‘void dfs(int, int)’:
answer.code:76:15: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
   76 |     for(int v:_rd[now]){
      |               ^~~
answer.code:76:22: error: forming reference to reference type ‘std::vector<int>&’
   76 |     for(int v:_rd[now]){
      |                      ^
answer.code: In function ‘int check(int)’:
answer.code:99:23: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
   99 |             for(int u:_have[d+A-B+1]){
      |                       ^~~~~
answer.code:99:36: error: forming reference to reference type ‘std::vector<int>&’
   99 |             for(int u:_have[d+A-B+1]){
      |                                    ^
answer.code:105:23: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
  105 |             for(int u:_have[d+A]){
      |                       ^~~~~
answer.code:105:32: error: forming reference to reference type ‘std::vector<int>&’
  105 |             for(int u:_have[d+A]){
      |                                ^
answer.code:110:19: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
  110 |         for(int u:_have[d]){
      |                   ^~~~~
answer.code:110:26: error: forming reference to reference type ‘std::vector<int>&’
  110 |         for(int u:_have[d]){
      |                          ^
answer.code:112:23: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
  112 |             for(int v:_rd[u]){
      |                       ^~~
answer.code:112:28: error: forming reference to reference type ‘std::vector<int>&’
  112 |             for(int v:_rd[u]){
      |                            ^
answer.code:119:23: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
  119 |             for(int v:_rd[u]){
      |                       ^~~
answer.code:119:28: error: forming reference to reference type ‘std::vector<int>&’
  119 |             for(int v:_rd[u]){
      |                            ^
answer.code:128:27: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
  128 |                 for(int v:_son[u]){
      |                           ^~~~
answer.code:128:33: error: forming reference to reference type ‘std::vector<int>&’
  128 |                 for(int v:_son[u]){
      |                                 ^
answer.code:139:23: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
  139 |             for(int v:_son[u]){
      |                       ^~~~
answer.code:139:29: error: forming reference to reference type ‘std::vector<int>&’
  139 |             for(int v:_son[u]){
      |                             ^
answer.code:144:23: warning: range-based ‘for’ loops only available with ‘-std=c++11’ or ‘-std=gnu++11’ [-Wc++11-extensions]
  144 |             for(int v:_rd[u]){
      |                       ^~~
answer.code:144:28: error: forming reference to reference type ‘std::vector<int>&’
  144 |             for(int v:_rd[u]){
      |                            ^
answer.code: In function ‘int main()’:
answer.code:161:12: warning: ignoring return value of ‘FILE* freopen(const char*, const char*, FILE*)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  161 |     freopen("fruit.in","r",stdin);
      |     ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~
answer.code:162:12: warning: ignoring return value of ‘FILE* freopen(const char*, const char*, FILE*)’ declared with attribute ‘warn_unused_result’ [-Wunused-result]
  162 |     freopen("fruit.out","w",stdout);
      |     ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~