problem

There are $ N $ islands numbered from $ 1 $ to $ N $.
Each island has $ N-1 $ bridges, allowing any $ 2 $ island to move to each other across several bridges.
Each bridge has durability, and the durability of the $ i $ th bridge given the input is $ w_i $.
There are $ 1 $ treasures on each island, and you can pick them up while you're on the island.

Yebi, who is currently on the island $ S $, wants to carry all the treasures to the museum on the island $ E $.
Since yebi has ✝ magical power ✝, every time he visits the island $ v $, the durability of all bridges coming out of $ v $ is reduced by $ T $.
When the durability of the bridge drops below $ 0 $, the bridge collapses and cannot be crossed after that.
Can yebi deliver all the treasures to the museum?
However, since yebi is powerful, he can carry as many treasures as he wants at the same time.



output

Output "Yes" if you can deliver all the treasures to the museum, otherwise output "No".
Also, output a line break at the end.

Example

Input

4 10 1 4
1 2 52
1 3 68
3 4 45


Output

Yes
#include "bits/stdc++.h"
#define YES "YES"
#define NO "NO"
#define YESNO OUT(three(solve(),YES,NO))
#define ECHO OUT(solve())
#define three(A,B,C) ((A)?(B):(C))
#define FOR(i,a,b)  for(LL i=(a);i< (LL)(b);i++)
#define EFOR(i,a,b) for(LL i=(a);i<=(LL)(b);i++)
#define RFOR(i,a,b) for(LL i=(b);i>=(LL)(a);i--)
#define REP(i,b) FOR(i,zero,b)
#define rep REP
#define EREP(i,b) EFOR(i,zero,b)
#define RREP(i,b) RFOR(i,b,zero)
#define ALL(c) c.begin(),c.end()
#define UNIQUE(c) sort(ALL(c));c.erase(unique(ALL(c)),c.end())
#define MAX(c) (*max_element(ALL(c)))
#define MIN(c) (*min_element(ALL(c)))
#define MP make_pair
#define FI first
#define SE second
#define SI(x) (LL(x.size()))
#define PB push_back
#define DEBUG(a) OUT(a)
#define DEBUG2(a,b) OUT2(a,b)
#define cat cout << __LINE__ << endl
#define OUT(a) cout << (a) << endl
#define OUT2(a,b) cout << (a) <<" "<<(b) << endl
#define zero 0LL
#define all ALL
#define pb emplace_back
#define eb pb
#define int long long
using namespace std;
template<typename T> inline void maximize(T &a, T b) { a = max(a, b); }
template<typename T> inline void minimize(T &a, T b) { a = min(a, b); }
template<typename T> inline bool middle(T a, T b, T c) { return b <= a && a <= c; }
template<class T> inline bool MX(T &l, const T &r) { return l < r ? l = r, 1 : 0; }
template<class T> inline bool MN(T &l, const T &r) { return l > r ? l = r, 1 : 0; }
typedef int LL;
typedef double ld;
typedef int ut;
typedef vector<ut> VI;
typedef vector<VI> VII;
typedef pair<ut, ut> pr;
typedef pair<ut, pr> ppr;
typedef vector<pr> Vpr;
typedef vector<ppr> Vppr;
typedef tuple<int, int, int, int> tapu;
typedef vector<tapu> Vtapu;
typedef priority_queue<tapu, Vtapu, greater<tapu> > PQ;
inline void outputVI(VI x) { REP(i, SI(x)) { cout << three(i, " ", "") << x[i]; }OUT(""); }
const int SIZE1 = 3e5 + 1000;
const int SIZE2 = 5010;
const int SIZE3 = 430;
const int SIZE = SIZE1;
const int MAPSIZE = 40;
const LL p = 7 + 1e9;
const LL INF = 1LL << 60;
const long double EPS = 1e-7;
typedef pair<ld, ut> pld;
 
int dx[]={0,0,1,-1};
int dy[]={-1,1,0,0};
LL N,T,S,E;
Vpr edges[SIZE];
Vpr nedges[SIZE];
LL to[SIZE];
LL fromlimit[SIZE];
LL tolimit[SIZE];
LL used[SIZE];
LL dfsed(int now,int from){
  for(auto ne:edges[now]){
    LL next=ne.second;
    if(next==from){
       fromlimit[now]=ne.first;
       continue;
    }
    if(dfsed(next,now)){
      to[now]=next;
      tolimit[now]=ne.first;
      return 1;
    }
  }
  if(now==E) return 1;
  to[now]=from;
  tolimit[now]=fromlimit[now];
  return 0;
}
LL dfs(int now,int from){
  sort(ALL(nedges[now]));
  if(from!=-1) used[now]+=T; 
  
  for(auto ne:nedges[now]){
    LL next=ne.second;
//    cout << ne.first <<" " << next << endl;
    if(next==from or to[now]==next) continue;
    if(used[now]>=ne.first){
      return 1;
    }
    if(dfs(next,now)){
      return 1; 
     
    }
    used[now]+=T;
  }
  if(now==E) return 0;
  for(auto ne:edges[now]){
    LL next=ne.second;
    if(to[now]!=next) continue;
//    cout << used[1] << " " << used[2] << endl;
    if(used[now]+used[next]>=ne.first){
      return 1;
    
    }
//    cout << to[now] << endl;
    if(to[now]!=from and dfs(next,now)){
      return 1; 
     
    }
  }
  return 0;
}
signed main(){
  cin >> N >> T >> S >> E;
  REP(i,N-1){
    LL a,b,c;
    cin >> a >> b >> c;
    edges[a].pb(c,b);
    edges[b].pb(c,a);
  }
  fromlimit[S]=INF;
  dfsed(S,-1);
  EFOR(i,1,N)
    for(auto ne:edges[i]){
      if(ne.second==to[i]) continue;
      nedges[i].pb(ne.first-T*(LL)edges[ne.second].size(),ne.second);
    }
  if(dfs(S,-1)){
    cout << "No" << endl;
  }else cout << "Yes" << endl;
  return 0;
}

