#include <bits/stdc++.h>

long long qpow(long long a, long long b, long long p) {
	return b ? (b & 1 ? (a * qpow(a, b - 1, p) % p)
					  : (qpow(a * a % p, b / 2, p) % p))
			 : 1ll;
}

class Dsu {
private:
	size_t n;
	std::vector<size_t> fa, siz;

public:
	Dsu(size_t n) : n(n), fa(n), siz(n) {
		for (size_t i = 0; i < n; ++i) fa[i] = i, siz[i] = 1;
	}
	Dsu() {}
	bool empty() { return n == 0; }
	size_t size() { return n; }
	void reset() {
		for (size_t i = 0; i < n; ++i) fa[i] = i, siz[i] = 1;
	}
	void resize(size_t _n) {
		n = _n;
		reset();
	}
	size_t get_father(size_t x) {
		return fa[x] == x ? x : fa[x] = get_father(fa[x]);
	}
	bool is_root(size_t x) { return get_father(x) == x; }
	bool merge(size_t _u, size_t _v) {
		_u = get_father(_u);
		_v = get_father(_v);
		if (_u == _v) return false;
		if (siz[_u] < siz[_v]) std::swap(_u, _v);
		fa[_u] = _v;
		siz[_v] += siz[_u];
		siz[_u] = 0;
		return true;
	}
	bool check(size_t _u, size_t _v) {
		return get_father(_u) == get_father(_v);
	}
	size_t size(size_t x) { return siz[get_father(x)]; }
};

struct Edge {
	int u, v;
	long long w;
};

const long long p = 998'244'353;

void solve() {
	int n;
	long long s;
	std::cin >> n >> s;
	std::vector<Edge> ed;
	for (int i = 0; i < n - 1; ++i) {
		int u, v;
		long long w;
		std::cin >> u >> v >> w;
		--u, --v;
		ed.push_back({u, v, w});
	}

	std::sort(ed.begin(), ed.end(), [](Edge a, Edge b) { return a.w < b.w; });

	long long ans = 1;
	Dsu D(n);

	for (int i = 0; i < n - 1; ++i) {
		int u, v;
		long long w;
		u = ed[i].u, v = ed[i].v, w = ed[i].w;
		if (s - w + 1 <= 0) continue;
		ans *= qpow(s - w + 1, (D.size(u) * D.size(v) - 1ll), p);
		ans %= p;
		D.merge(u, v);
	}

	std::cout << ans << '\n';
}

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

Wrong answer on test 26.