#include <bits/stdc++.h>

constexpr int mod = 998'244'353;

int add(int a, int b) {
    return a + b - mod * (a + b >= mod);
}
void add_to(int& a, int b) {
    a = add(a, b);
}
int mul(int a, int b) {
    return a * 1ULL * b % mod;
}
int power(int b, int e) {
    int r = 1;
    for (; e > 0; e >>= 1) {
        if (e & 1)
            r = mul(r, b);
        b = mul(b, b);
    }
    return b;
}

struct ST {
    struct Data {
        int sum_val;
        int sum;

        Data(int val = 0) : sum_val(val), sum(0) { ; }
    };

    Data merge(Data a, const Data& b) const {
        add_to(a.sum, b.sum);
        add_to(a.sum_val, b.sum_val);
        return a;
    }

    std::vector<Data> data;
    int size;

    ST() = default;

    ST(int n) {
        data.assign(n, Data(0));
    }

    void add_val(int l, int r, int val) {
        for (int i = l; i < r; i++) {
            add_to(data[i].sum_val, val);
        }
    }

    void add_all() {
        for (int i = 0; i < data.size(); i++) {
            add_to(data[i].sum, data[i].sum_val);
        }
    }

    void clear(int l) {
        for (int i = l; i < data.size(); i++) {
            data[i] = Data(0);
        }
    }

    int get_sum(int i) {
        return data[i].sum;
    }

    void merge(const ST& other) {
        assert(other.data.size() == data.size());
        for (int i = 0; i < data.size(); i++) {
            data[i] = merge(data[i], other.data[i]);
        }
    }
};

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> prev(n, -1), max_depth(n, -1);
    std::vector<std::pair<int, int>> input(n);
    std::vector<std::vector<int>> gr(n);
    for (int i = 1; i < n; i++) {
        std::cin >> prev[i] >> input[i].first >> input[i].second >> max_depth[i];
        prev[i]--;
        gr[prev[i]].push_back(i);
    }
    std::vector<int> depth(n);
    for (int i = 1; i < n; i++) {
        depth[i] = depth[prev[i]] + 1;
        max_depth[i] = depth[i] - max_depth[i] - 1;
    }
    std::vector<int> ord(n);
    std::iota(ord.begin(), ord.end(), 0);
    std::sort(ord.begin(), ord.end(), [&](int a, int b) { return depth[a] < depth[b]; });
    std::vector<int> ans(n, 0);

    for (int i = 1; i < n; i++) {
        std::vector<std::vector<int>> dp(n + 1, std::vector<int>(n));
        dp[max_depth[i] + 1][i] = 1;
        for (int j = n; j >= 0; j--) {
            auto dfs = [&](auto dfs, int v, int sum) -> void {
                if (max_depth[v] + 1 < j) {
                    assert(dp[j][v] == 0);
                    add_to(dp[max_depth[v] + 1][v], sum);
                    dp[j][v] = 0;
                    for (int t : gr[v]) {
                        dfs(dfs, t, 0);
                    }
                    return;
                }
                add_to(sum, dp[j][v]);
                dp[j][v] = sum;
                for (int t : gr[v]) {
                    dfs(dfs, t, sum);
                }
            };
            dfs(dfs, 0, 0);

            for (int t = 1; t < n; t++) {
                if (dp[j][t] == 0) {
                    continue;
                }
                for (int r = 0, v = t; r <= input[t].second; r++, v = prev[v]) {
                    if (input[t].first <= r && depth[v] < j) {
                        add_to(dp[max_depth[v] + 1][v], dp[j][t]);
                    }
                }
            }
        }
        ans[i] = dp[0][0];
    }

    for (int i = 1; i < n; i++) {
        std::cout << ans[i] << " \n"[i == n - 1];
    }
}

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int g, t;
    std::cin >> g >> t;
    while (t--) {
        solve();
    }

    return 0;
}