#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 mod = 998244353;
const int UQ = 1420696969;

namespace segtree {
	const int LIM = 5e6;
	const int DL = 0, DR = 5;
	int cf[LIM], lc[LIM], rc[LIM], sv[LIM], ss[LIM], cc[LIM];
	int rt[LIM], rv[LIM], rx[LIM];
	int nxt = 1, rxt = -1;
	
	void reset() {nxt=1,rxt=-1;}
	int create() {
		cf[nxt]=lc[nxt]=rc[nxt]=sv[nxt]=ss[nxt]=cc[nxt]=0;
		return nxt++;
	}
	void pull(int v) {
		sv[v] = (cf[v]*ss[v])%mod;
		if (lc[v]) sv[v]+=sv[lc[v]];
		if (rc[v]) sv[v]+=sv[rc[v]];
		sv[v] %= mod;
		cc[v] = 1; //cleared
		if (lc[v] && !cc[lc[v]]) {cc[v]=0;}
		if (rc[v] && !cc[rc[v]]) {cc[v]=0;}
		if (cf[v]) {cc[v]=0;}
	}
	void buf() {rt[++rxt]=0;}
	void f(int v, int x) {
		cf[v] = ((cf[v]+x)%mod+mod)%mod;
		rt[++rxt] = 1;
		rv[rxt] = v; rx[rxt] = x;
		pull(v);
	}
	void push(int v) {
		if (!lc[v]) lc[v] = create();
		if (!rc[v]) rc[v] = create();
		f(lc[v],cf[v]);
		f(rc[v],cf[v]);
		f(v,-cf[v]);
	}
	void range_add_coef(int ql, int qr, int qx, int cp, int cl, int cr) {
		if (ql > cr || qr < cl) return;
		if (ql <= cl && cr <= qr) {
			f(cp,qx);
		} else {
			if (!lc[cp]) lc[cp] = create();
			if (!rc[cp]) rc[cp] = create();
			range_add_coef(ql,qr,qx,lc[cp],cl,(cl+cr)/2);
			range_add_coef(ql,qr,qx,rc[cp],(cl+cr)/2+1,cr);
			pull(cp);
		}
	}
	void range_add_coef(int ql, int qr, int qx, int cp) {
		buf();
		range_add_coef(ql,qr,qx,cp,DL,DR);
	}
	void clear(int ql, int qr, int cp, int cl, int cr) {
		if (ql > cr || qr < cl) return;
		if (cc[cp]) return;
		if (ql <= cl && cr <= qr) {
			f(cp,-cf[cp]);
		} else {push(cp);}
		if (lc[cp]) clear(ql,qr,lc[cp],cl,(cl+cr)/2);
		if (rc[cp]) clear(ql,qr,rc[cp],(cl+cr)/2+1,cr);
		pull(cp);
	}
	void clear(int ql, int qr, int cp) {
		buf();
		clear(ql,qr,cp,DL,DR);
	}
	void set_dp(int qi, int qx, int cp, int cl=DL, int cr=DR) {
		ss[cp] += qx;
		if (cl != cr) {
			if (qi <= (cl+cr)/2) {
				if (!lc[cp]) lc[cp] = create();
				set_dp(qi,qx,lc[cp],cl,(cl+cr)/2);
			} else {
				if (!rc[cp]) rc[cp] = create();
				set_dp(qi,qx,rc[cp],(cl+cr)/2+1,cr);
			}
		}
		pull(cp);
	}
	int merge(int r1, int r2) {
		if (!r1) return r2;
		if (!r2) return r1;
		rt[++rxt] = 4, rv[rxt] = r1, rx[rxt] = r2;
		f(r1,cf[r2]);
		rt[++rxt] = 2, rv[rxt] = r1, rx[rxt] = lc[r1];
		rt[++rxt] = 3, rv[rxt] = r1, rx[rxt] = rc[r1];
		lc[r1] = merge(lc[r1],lc[r2]);
		rc[r1] = merge(rc[r1],rc[r2]);
		pull(r1);
		return r1;
	}
	int MERGE(int r1, int r2) {
		buf();
		return merge(r1,r2);
	}
	void rollback() {
		assert(rxt>=0);
		while (rt[rxt]) {
			if (rt[rxt]==1) {
				cf[rv[rxt]] -= rx[rxt];
			} else if (rt[rxt]==2) {
				lc[rv[rxt]] = rx[rxt];
			} else if (rt[rxt]==3) {
				rc[rv[rxt]] = rx[rxt];
			} else if (rt[rxt]==4) {
				ss[rx[rxt]] = ss[rv[rxt]];
				pull(rx[rxt]);
			} else {assert(0);}
			pull(rv[rxt]); rxt--;
		}
		rxt--;
	}
	int get(int r) {return sv[r];}
}

const int mxn=1e5;

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

void dfs_depth(int v, int dep) {
	d[v] = dep;
	for (int u : adj[v]) {
		dfs_depth(u,dep+1);
	}
}

void dfs(int v) {
	for (int u : adj[v]) {
		dfs(u);
	}
	for (int u : adj[v]) {
		sgt[v] = segtree::MERGE(sgt[v],sgt[u]);
	}
	int lodep = d[v]-r[v];
	int hidep = d[v]-l[v];
	segtree::range_add_coef(lodep,hidep,1,sgt[v]);
	int bad = d[v]-h[v];
	segtree::clear(bad,segtree::DR,sgt[v]);
}

void undo(int v) {
	if (v) {
		dp[v] = segtree::get(sgt[v]);
	} else {
		dp[v] = 1;
	}
	segtree::rollback();
	segtree::rollback();
	for (int u : adj[v]) {
		segtree::rollback();
	}
	reverse(all(adj[v]));
	for (int u : adj[v]) {
		segtree::set_dp(d[v],dp[v],sgt[u]);
		undo(u);
	}
}

void solve() {
	segtree::reset();
	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]; adj[p[i]].push_back(i);
	}
	dfs_depth(0,0);
	for (int i=0; i<n; i++) {
		sgt[i] = segtree::create();
	}
	dfs(0);
	undo(0);
	for (int i=1; i<n; i++) {
		cout<<dp[i]<<" ";
	}
	cout<<"\n";
}

signed main() {
	ios::sync_with_stdio(false); cin.tie(nullptr);
	
	int c,t; cin>>c>>t;
	while (t--) {
		solve();
	}
	
	return 0;
}