#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define int long long
#define all(x) begin(x), end(x)
#define sz(x) (int) (x).size()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

const int mxn = 1e5+1;
const int mod = 998244353;

int n, mxd;
int p[mxn],l[mxn],r[mxn],h[mxn],d[mxn];
vector<int> adj[mxn];

namespace solve1 {
	vector<vector<int>> dp;
	void solve() {
		// dp[i][j] = vertex i, required max depth j
		for (int i=1; i<n; i++) {
			int ans = 0;
			dp = vector<vector<int>>(n,vector<int>(mxd+1,0));
			dp[i][d[i] - h[i]] = 1;
			for (int k=d[i]-h[i]; k>=0; k--) {
				ans += dp[0][k];
				ans %= mod;
				for (int v = 0; v < n; v++) {
					if (!dp[v][k]) continue;
					//rest
					for (int c : adj[v]) {
						int smt = min(k,d[c]-h[c]);
						dp[c][smt] += dp[v][k];
						dp[c][smt] %= mod;
					}
					//sprint
					int cp = p[v];
					while (1) {
					//	cout<<v<<": "<<cp<<"\n";
						if (d[v]-d[cp] >= l[v] && d[v]-d[cp] <= r[v] && d[cp] < k) {
							int smt = min(k,d[cp]-h[cp]);
							dp[cp][smt] += dp[v][k];
							dp[cp][smt] %= mod;
						}
						if (cp == 0) break;
						cp = p[cp];
					}
				}
			}
			cout<<ans<<" ";
		}
		cout<<"\n";
	}
}

signed main() {
	ios::sync_with_stdio(false); cin.tie(nullptr);
	int c,t; cin>>c>>t;
	while (t--) {
		mxd = 0;
		cin >> n;
		for (int i=0; i<n; i++) {
			adj[i].clear();
		}
		for (int i=1; i<n; i++) {
			cin >> p[i] >> l[i] >> r[i] >> h[i];
			--p[i];
			d[i] = 1 + d[p[i]];
			mxd = max(mxd, d[i]);
			adj[p[i]].push_back(i);
		}
		solve1::solve();
	}
	
	return 0;
}