#include <bits/stdc++.h>

#include "closing.h"

#if defined(LOCAL)
#define DBG_MACRO_NO_WARNING
#include <dbg.hpp>

#include "grader.cpp"
#else
#define dbg(x...) (0)
#endif

using namespace std;

using ll = long long;

// #define int ll
#define rep(i, f, t) for (int i = (f), ed##i = (t); i <= ed##i; ++i)
#define re(i, t) rep (i, 1, t)
#define per(i, t, f) for (int i = (t), ed##i = (f); i >= ed##i; --i)
#define ste(i, f, t, s) for (int i = (f), ed##i = (t); i <= ed##i; i += s)
#define nxt(i, f, g) for (int i = g.h[f]; i; i = g.e[i].n)
#define umod(x) ((x) >= mo && ((x) -= mo))
#define dmod(x) ((x) < 0 && ((x) += mo))
#define y1 y1__
#define fio(x) (freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout))

template <class T, class E>
__attribute__((always_inline)) inline void up(T &x, E &&y) {
  if (x < y) x = y;
}
template <class T, class E>
__attribute__((always_inline)) inline void down(T &x, E &&y) {
  if (y < x) x = y;
}

const int N = 1e6 + 9;
const ll inf = 1e18 + 9;

struct E {
  int f, t, v;
} es[N];
int n, X, Y, a[N];
ll m, dis[N][3];
vector<pair<int, int>> e[N];
struct Node {
  ll v;
  int p, f;
};
inline bool operator<(Node x, Node y) { return x.v > y.v; }
priority_queue<Node> q[3];

inline void Dfs1(int f, int fa, int id) {
  for (auto [t, v] : e[f]) {
    if (t == fa) continue;
    dis[t][id] = dis[f][id] + v;
    Dfs1(t, f, id);
  }
}

inline void Push(int p, int x) {
  a[p] = x;
  rep (i, max(x - 1, 0), 2) {
    if (i == x) continue;
    q[max(0, i - x)].push({dis[p][i] - dis[p][x], p, x});
  }
}

inline int Work() {
  rep (i, 0, 2) q[i] = {};
  re (i, n) e[i].clear();
  re (i, n - 1) {
    auto [f, t, v] = es[i];
    e[f].push_back({t, v});
    e[t].push_back({f, v});
  }
  dis[X][1] = dis[Y][2] = 0;
  Dfs1(X, 0, 1);
  Dfs1(Y, 0, 2);
  re (i, n)
    if (dis[i][1] > dis[i][2]) swap(dis[i][1], dis[i][2]);
  ll sum = 0, ans = 0;
  re (i, n)
    if (dis[i][1] + dis[i][2] == dis[X][2]) {
      sum += dis[i][1];
      Push(i, 1);
      ++ans;
    } else
      Push(i, 0);
  if (m < sum) {
    int res = 0;
    vector<ll> vec;
    re (i, n) vec.push_back(dis[i][1]);
    sort(vec.begin(), vec.end());
    // dbg(vec);
    for (auto x : vec)
      if (m >= x)
        m -= x, ++res;
      else
        return res;
  }
  m -= sum;
  // dbg(m, ans);
  while (1) {
    rep (i, 0, 2)
      while (q[i].size()) {
        auto tp = q[i].top();
        if (a[tp.p] != tp.f)
          q[i].pop();
        else
          break;
      }
    if (ll c1 = q[1].empty() ? inf : q[1].top().v,
        c2 = (q[2].empty() ? inf : q[2].top().v) + (q[0].empty() ? inf : q[0].top().v);
        c1 < c2) {
      // dbg(c1);
      if (m < c1) break;
      m -= c1;
      ++ans;
      auto tp = q[1].top();
      q[1].pop();
      Push(tp.p, tp.f + 1);
      // cerr << "1 " << tp.v << ' ' << tp.p << ' ' << tp.f << '\n';
    } else {
      if (m < c2) break;
      m -= c2;
      ++ans;
      auto tp = q[2].top();
      q[2].pop();
      Push(tp.p, tp.f + 2);
      // cerr << "2 " << tp.v << ' ' << tp.p << ' ' << tp.f << '\n';
      tp = q[0].top();
      q[0].pop();
      Push(tp.p, tp.f - 1);
      // cerr << "-1 " << tp.v << ' ' << tp.p << ' ' << tp.f << '\n';
    }
  }
  // dbg(ans);
  return ans;
}

int max_score(int N, int X, int Y, long long K, std::vector<int> U, std::vector<int> V,
              std::vector<int> W) {
  ::n = N, ::X = X + 1, ::Y = Y + 1, ::m = K;
  rep (i, 0, n - 2) es[i + 1] = {U[i] + 1, V[i] + 1, W[i]};
  return Work();
}