#include <bits/stdc++.h>

#define ll long long
#define ld  double
using namespace std;

// #define int ll

const int N = 300 + 5, mod = 998244353;


int n, total, s[N], power[N];
int dp[N][N][2];

vector<int> adj[N];

vector<int> dpCan[N][N], dpCanT[N][N];


int solveCanTaken(int node, int rem, int idx, int par) {
    if((int) adj[node].size() == idx) return 0;
    if(dpCan[node][rem][idx] != -1) return dpCan[node][rem][idx];

    int child = adj[node][idx];
    if(child == par) return dpCan[node][rem][idx] = solveCanTaken(node, rem, idx + 1, par);

    int ans = 0;
    for(int i = 0; i <= rem; i++) {
        ans = max(ans, dp[child][i][1] + solveCanTaken(node, rem - i, idx + 1, par));
    }
    return dpCan[node][rem][idx] = ans;
}

int solveCanTTaken(int node, int rem, int idx, int par) {
    if((int) adj[node].size() == idx) return 0;
    if(dpCanT[node][rem][idx] != -1) return dpCanT[node][rem][idx];

    int child = adj[node][idx];
    if(child == par) return dpCanT[node][rem][idx] = solveCanTTaken(node, rem, idx + 1, par);

    int ans = 0;
    for(int i = 0; i <= rem; i++) {
        ans = max(ans, dp[child][i][0] + solveCanTTaken(node, rem - i, idx + 1, par));
    }

    return dpCanT[node][rem][idx] = ans;
}


void solve(int node, int par) {
    for(auto i: adj[node]) {
        if(i == par) continue;
        solve(i, node);
    }

    for(int rem = 0; rem <= total; rem++) {
        dp[node][rem][0] = solveCanTaken(node, rem, 0, par);
        dp[node][rem][1] = dp[node][rem][0];
        if(rem >= s[node]) {
            int op2 = power[node] + solveCanTTaken(node, rem - s[node], 0, par);
            dp[node][rem][1] = max(dp[node][rem][1], op2);
        }
    }
}


int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    cin >> n >> total;
    for(int i = 1; i <= n; i++) {
        cin >> s[i] >> power[i];
    }

    for(int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    for(int i = 1; i <= n; i++) {
        for(int j = 0; j <= total; j++) {
                dpCan[i][j] = vector<int>((int) adj[i].size(), -1);
                dpCanT[i][j] = dpCan[i][j];
            }
        }


    solve(1, 0);

    int ans = 0;
    for(int i = 0; i <= total; i++) ans = max(ans, dp[1][i][1]);
    cout << ans;




    return 0;
}