#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

const int N = 2e5, E = N << 1, SZ = N << 2;
const long long P = 998244353, Inv2 = (P + 1) >> 1;

int n, Left, Right, W;
long long ans[N + 5];

int head[N + 5], to[E + 5], nxt[E + 5], tot = 1;
void add_edge(int u, int v)
{
	tot++;
	to[tot] = v;
	nxt[tot] = head[u];
	head[u] = tot;
	return ;
}
void add(int u, int v)
{
	add_edge(u, v);
	add_edge(v, u);
	return ;
}

long long ksm(long long d, long long u)
{
	long long res = 1;
	while (u)
	{
		if (u & 1)
			res = res * d % P;
		u >>= 1;
		d = d * d % P;
	}
	return res;
}

struct Integer
{
	long long val;
	int zero;

	Integer()
	{
		val = 1, zero = 0;
	}
	void multiply(long long x)
	{
		if (!x)
			zero++;
		else
			val = val * x % P;
		return ;
	}
	void divide(long long x)
	{
		if (!x)
			zero--;
		else
			val = val * ksm(x, P - 2) % P;
		return ;
	}
	long long get()
	{
		return (!zero) * val;
	}
};

struct Function
{
	long long k, b;

	Function operator * (const Function& fun) const
	{
		return Function{k * fun.k % P, (b * fun.k % P + fun.b) % P};
	}
};

struct SegmentTree
{
	Function fun[SZ + 5];

	#define ls(p) (p << 1)
	#define rs(p) (p << 1 | 1)

	void pushup(int p)
	{
		fun[p] = fun[rs(p)] * fun[ls(p)];
		return ;
	}
	void modify(int p, int l, int r, int pos, Function func)
	{
		if (l == r)
			return fun[p] = func, void();
		int mid = (l + r) >> 1;
		if (pos <= mid)
			modify(ls(p), l, mid, pos, func);
		else
			modify(rs(p), mid + 1, r, pos, func);
		pushup(p);
		return ;
	}
	Function query(int p, int l, int r, int L, int R)
	{
		if (L <= l && r <= R)
			return fun[p];
		int mid = (l + r) >> 1;
		if (R <= mid)
			return query(ls(p), l, mid, L, R);
		if (L > mid)
			return query(rs(p), mid + 1, r, L, R);
		return query(rs(p), mid + 1, r, L, R) * query(ls(p), l, mid, L, R);
	}
} tree;

int w[N + 5], opt[N + 5];//whether changing is better
long long s[N + 5];//subsets

int fa[N + 5], dep[N + 5], sz[N + 5], son[N + 5];
int dfn[N + 5], top[N + 5], tail[N + 5], tim;

Integer dp[N + 5];//light son, init = 1, dep = 1, dp = >W; dep = 0, dp = <W
long long Dp[N + 5];//all son

void dfs0(int u, int father, int depth)
{
	fa[u] = father, dep[u] = depth, sz[u] = 1;
	w[u] = (!depth) * n, s[u] = 1;

	for (int i = head[u]; i; i = nxt[i])
	{
		int v = to[i];
		if (v == father)
			continue;

		dfs0(v, u, !depth);
		s[u] = s[u] * s[v] % P;
		sz[u] += sz[v];

		if (depth)
			w[u] = max(w[u], w[v]);
		else
			w[u] = min(w[u], w[v]);
	}

	if (sz[u] == 1)
		w[u] = u, s[u] = 2;
	return ;
}
void dfs1(int u)
{
	for (int i = head[u]; i; i = nxt[i])
	{
		int v = to[i];
		if (v == fa[u])
			continue;

		dfs1(v);
		if (w[u] == W)
		{
			if (w[v] == W)
				son[u] = v;
			continue;
		}
		if (!son[u] || sz[son[u]] < sz[v])
			son[u] = v;
	}
	return ;
}
int dfs2(int u, int tp, int deplca)
{
	dfn[u] = ++tim, top[u] = tp;

	opt[u] = deplca ^ (u > W);//1, u < W; 0, u > W
	if (w[u] == W)
		deplca = dep[u];

	tail[u] = u;//leaf
	if (son[u])
		tail[u] = dfs2(son[u], tp, deplca);

	for (int i = head[u]; i; i = nxt[i])
	{
		int v = to[i];
		if (v == fa[u] || v == son[u])
			continue;

		dfs2(v, v, deplca);
		dp[u].multiply(Dp[v]);
	}
	Dp[u] = (s[u] - dp[u].get() * Dp[son[u]] % P + P) % P;

	Function func;
	if (u == W)
		func = Function{0, 1};
	else if (sz[u] == 1)//leaf
	{
		func = Function{0, ((u < W) ^ dep[u]) * 2};
		Dp[u] = func.b;
	}
	else if (w[u] == W)//on chain or W
		func = Function{dp[u].get(), 0};
	else
		func = Function{(P - dp[u].get()) % P, s[u]};

	tree.modify(1, 1, n, dfn[u], func);
	return tail[u];
}

void update(int u)
{
	Function func;

	int p = u;
	while (w[p] != W)//delete
	{
		int tp = top[p], anc = fa[tp];
		func = tree.query(1, 1, n, dfn[tp], dfn[tail[tp]]);
		dp[anc].divide(func.b);
		p = anc;
	}
	tree.modify(1, 1, n, dfn[u], Function{0, 1});//f = g = 1

	p = u;
	while (w[p] != W)//add
	{
		int tp = top[p], anc = fa[tp];
		func = tree.query(1, 1, n, dfn[tp], dfn[tail[tp]]);
		
		dp[anc].multiply(func.b);
		if (w[anc] == W)
			func = Function{dp[anc].get(), 0};
		else
			func = Function{(P - dp[anc].get()) % P, s[anc]};

		tree.modify(1, 1, n, dfn[anc], func);
		p = anc;
	}
	return ;
}

int main()
{
	// freopen("minimax.in", "r", stdin);
	// freopen("minimax.out", "w", stdout);

	scanf("%d%d%d", &n, &Left, &Right);
	for (int i = 1, u, v; i < n; i++)
	{
		scanf("%d%d", &u, &v);
		add(u, v);
	}

	dfs0(1, 0, 1);
	W = w[1];
	dfs1(1);
	dfs2(1, 1, 0);

	ans[1] = s[1] * Inv2 % P;
	for (int k = 2; k < n; k++)
	{
		if (W - k + 1 > 0 && sz[W - k + 1] == 1 && opt[W - k + 1])//lca: max, top: min
			update(W - k + 1);

		if (W + k - 1 <= n && sz[W + k - 1] == 1 && opt[W + k - 1])//lca: min, top: max
			update(W + k - 1);

		ans[k] = (s[1] + P - tree.query(1, 1, n, 1, tail[1]).b) % P;
	}
	ans[n] = (s[1] + P - 1) % P;

	for (int k = Left; k <= Right; k++)
		printf("%lld ", (ans[k] + P - ans[k - 1]) % P);
	printf("\n");
	return 0;
}