#include <bits/stdc++.h>
using namespace std;

#define INF_LL (int64)1e18
#define INF (int32)1e9
#define REP(i, n) for(int64 i = 0;i < (n);i++)
#define FOR(i, a, b) for(int64 i = (a);i < (b);i++)
#define all(x) x.begin(),x.end()
#define fs first
#define sc second

using int32 = int_fast32_t;
using uint32 = uint_fast32_t;
using int64 = int_fast64_t;
using uint64 = uint_fast64_t;
using PII = pair<int32, int32>;
using PLL = pair<int64, int64>;

const double eps = 1e-10;

template<typename A, typename B>inline void chmin(A &a, B b){if(a > b) a = b;}
template<typename A, typename B>inline void chmax(A &a, B b){if(a < b) a = b;}

template<typename T>
vector<T> make_v(size_t a){return vector<T>(a);}

template<typename T,typename... Ts>
auto make_v(size_t a,Ts... ts){
  return vector<decltype(make_v<T>(ts...))>(a,make_v<T>(ts...));
}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value!=0>::type
fill_v(U &u,const V... v){u=U(v...);}

template<typename T,typename U,typename... V>
typename enable_if<is_same<T, U>::value==0>::type
fill_v(U &u,const V... v){
  for(auto &e:u) fill_v<T>(e,v...);
}

vector<PLL> G[112345];
vector<int64> path;
vector<int64> cnt;
int64 N, S, E, T;

void calc_path() {
    queue<int64> q;
    vector<int64> d(N, INF);
    q.push(S);
    d[S] = 0;
    while (q.size()) {
        int64 v = q.front(); q.pop();
        REP(i, G[v].size()) {
            int64 u, w;
            tie(w, u) = G[v][i];
            if (d[u] > d[v]+1) {
                d[u] = d[v]+1;
                q.push(u);
            }
        }
    }
    q.push(E);
    path.push_back(E);
    while (q.size()) {
        int64 v = q.front(); q.pop();
        REP(i, G[v].size()) {
            int64 u, w;
            tie(w, u) = G[v][i];
            if (d[u] + 1 == d[v]) {
                q.push(u);
                path.push_back(w);
                path.push_back(u);
            }
        }
    }
    reverse(all(path));
}

bool dfs(int64 v, int64 p1, int64 p2) {
    REP(i, G[v].size()) {
        int64 w, u;
        tie(w, u) = G[v][i];
        if (u == p1 || u == p2) continue;
        if ((cnt[v]+cnt[u])*T >= w) {
            return 0;
        }
        cnt[u]++;
        if (!dfs(u, v, v)) return false;
        if ((cnt[v]+cnt[u])*T >= w) {
            return 0;
        }
        cnt[v]++;
    }
    return 1;
}

bool solve() {
    for (int64 i = 0; i < path.size(); i+=2) {
        int64 pr = (i == 0 ? -1 : path[i-2]), nx = (i == path.size()-1 ? -1 : path[i+2]), v = path[i];
        if (i > 0) {
            if (cnt[pr]*T >= path[i-1]) {
                return 0;
            }
            cnt[v]++;
        }
        if (!dfs(v, pr, nx)) {
            return false;
        }
    }

    return true;
}

int main(void){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cin >> N >> T >> S >> E; S--; E--;
	REP(i, N-1) {
	    int64 a, b, w;
	    cin >> a >> b >> w; a--; b--;
	    G[a].emplace_back(w, b);
        G[b].emplace_back(w, a);
	}
	REP(i, N) {
	    sort(all(G[i]), [&](PLL &a, PLL &b) {
	        return (a.fs-G[a.sc].size()*T) < (b.fs-G[b.sc].size()*T);
	    });
	}
	cnt.resize(N, 0);

	calc_path();
	if (solve()) {
	    cout << "Yes" << endl;
	} else {
	    cout << "No" << endl;
	}
}




Measured memory_bytes: 12664