#include <bits/stdc++.h>
namespace loquat {
using vertex_t = size_t;
}
namespace loquat {
namespace edge_param {
struct to_ {
  vertex_t to;
  explicit to_(vertex_t t = 0) : to(t) {}
};
}  // namespace edge_param
namespace detail {
template <typename T, typename... Params>
struct edge_param_wrapper : public T, edge_param_wrapper<Params...> {};
template <typename T>
struct edge_param_wrapper<T> : public T {
  template <typename U>
  explicit edge_param_wrapper(U&& x) : T(std::forward<U>(x)) {}
};
}  // namespace detail
template <typename... Params>
struct edge : public detail::edge_param_wrapper<edge_param::to_, Params...> {
  template <typename... Args>
  explicit edge(Args&&... args)
      : detail::edge_param_wrapper<edge_param::to_, Params...>(
            std::forward<Args>(args)...) {}
};
}  // namespace loquat
namespace loquat {
template <typename EdgeType>
class adjacency_list {
 public:
  using edge_type = EdgeType;
  using edge_list = std::vector<edge_type>;

 private:
  std::vector<std::vector<EdgeType>> m_edges;

 public:
  explicit adjacency_list(size_t n) : m_edges(n) {}
  const edge_list& operator[](vertex_t u) const { return m_edges[u]; }
  template <typename... Args>
  void add_edge(vertex_t from, Args&&... args) {
    m_edges[from].emplace_back(std::forward<Args>(args)...);
  }
};
}  // namespace loquat
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using edge = loquat::edge<>;
static const ll INF = 1000000000000000000ll;
static vector<pll> solve(int u, const vector<pll>& prices,
                         const loquat::adjacency_list<edge>& g) {
  vector<pll> x = {pll(0, 0)};
  for (const auto& e : g[u]) {
    const auto y = solve(e.to, prices, g);
    vector<pll> z(x.size() + y.size() - 1, pll(INF, INF));
    for (size_t i = 0; i < x.size(); ++i) {
      for (size_t j = 0; j < y.size(); ++j) {
        z[i + j].first = min(z[i + j].first, x[i].first + y[j].first);
        z[i + j].second = min(z[i + j].second, x[i].first + y[j].second);
        z[i + j].second = min(z[i + j].second, x[i].second + y[j].first);
        z[i + j].second = min(z[i + j].second, x[i].second + y[j].second);
      }
    }
    x = move(z);
  }
  vector<pll> z(x.size() + 1, pll(INF, INF));
  for (size_t i = 0; i < x.size(); ++i) {
    z[i].first = x[i].first;
  }
  for (size_t i = 0; i < x.size(); ++i) {
    z[i + 1].first = min(z[i + 1].first, x[i].first + prices[u].first);
    z[i + 1].second = x[i].second + prices[u].second;
  }
  return z;
}
int main() {
  ios_base::sync_with_stdio(false);
  int n, b;
  cin >> n >> b;
  loquat::adjacency_list<edge> g(n);
  vector<pll> prices(n);
  for (int i = 0; i < n; ++i) {
    ll a, b;
    cin >> a >> b;
    prices[i] = pll(a, a - b);
    if (i > 0) {
      int p;
      cin >> p;
      g.add_edge(p - 1, i);
    }
  }
  const auto result = solve(0, prices, g);
  int answer = 0;
  while (answer < n) {
    const auto t = result[answer + 1];
    if (t.first > b && t.second > b) {
      break;
    }
    ++answer;
  }
  cout << answer << endl;
  return 0;
}
