#include<cstdio>

#include<cstring>

#include<queue>

#include<algorithm>

using namespace std;

const int maxn =  + ;

int T, n, m;

vector<int>tree[maxn];

struct kind

{

    int price;

    int power;

    kind(int a, int b){ price = a; power = b; }

};

vector<kind>v[maxn];

bool vis[maxn];

int dp[maxn][ + ];

int flag[ + ], tmp[ + ];

void init()

{

    for (int i = ; i <= n; i++) tree[i].clear();

    for (int i = ; i <= n; i++) v[i].clear();

    memset(vis, , sizeof vis);

    memset(dp, -, sizeof dp);

}

void read()

{

    scanf("%d", &n);

    for (int i = ; i <= n - ; i++)

    {

        int u, v;

        scanf("%d%d", &u, &v);

        tree[u].push_back(v);

        tree[v].push_back(u);

    }

    scanf("%d", &m);

    for (int i = ; i <= n; i++)

    {

        int ki;

        scanf("%d", &ki);

        while (ki--)

        {

            int pricei, poweri;

            scanf("%d%d", &pricei, &poweri);

            kind k(pricei, poweri);

            v[i].push_back(k);

        }

    }

}

void dfs(int now)

{

    bool fail = ;

    for (int i = ; i<tree[now].size(); i++)

        if (!vis[tree[now][i]]) fail = ;

    if (fail)

    {

        for (int i = ; i<v[now].size(); i++)

            dp[now][v[now][i].price] = max(dp[now][v[now][i].price], v[now][i].power);

        return;

    }

    bool d[maxn];

    memset(d, , sizeof d);

    for (int i = ; i<tree[now].size(); i++)

    {

        if (vis[tree[now][i]]) continue;

        int id = tree[now][i];

        vis[id] = ; dfs(id); d[i] = ;

    }

    memset(flag, -, sizeof flag);

    bool first = ;

    for (int i = ; i<tree[now].size(); i++)

    {

        if (!d[i]) continue;

        int id = tree[now][i];

        if (first)

        {

            first = ;

            for (int j = ; j <= m; j++) flag[j] = dp[id][j];

        }

        else

        {

            memset(tmp, -, sizeof tmp);

            for (int j = ; j <= m; j++)

                for (int k = ; k <= m; k++)

                    if (dp[id][j] != - && flag[k] != - && j + k <= m)

                        tmp[j + k] = max(tmp[j + k], min(dp[id][j], flag[k]));

            for (int j = ; j <= m; j++) flag[j] = tmp[j];

        }

    }

    for (int i = ; i<v[now].size(); i++)

        for (int j = m; j >= v[now][i].price; j--)

            if (flag[j - v[now][i].price] != -)

                dp[now][j] = max(dp[now][j], flag[j - v[now][i].price] + v[now][i].power);

    for (int i = ; i <= m; i++) dp[now][i] = max(dp[now][i], flag[i]);

    for (int i = ; i<v[now].size(); i++)

        dp[now][v[now][i].price] = max(dp[now][v[now][i].price], v[now][i].power);

}

void work()

{

    vis[] = ;

    dfs();

    int ans = ;

    for (int i = ; i <= m; i++) ans = max(ans, dp[][i]);

    printf("%d\n", ans);

}

int main()

{

    scanf("%d", &T);

    while (T--)

    {

        init();

        read();

        work();

    }

    return ;

}