#include <cstdio>
#include <utility>
#include <algorithm>
#define ls (p << 1)
#define rs (ls | 1)
using namespace std;
const int N = 2e5;
const int mod = 998244353;
const int inv = 499122177;
inline int fpow(int a,int b)
{
    int ret = 1;
    for(;b;b >>= 1)
        (b & 1) && (ret = (long long)ret * a % mod),a = (long long)a * a % mod;
    return ret;
}
int n,L,R;
int to[(N << 1) + 5],pre[(N << 1) + 5],first[N + 5];
inline void add(int u,int v)
{
    static int tot = 0;
    to[++tot] = v,pre[tot] = first[u],first[u] = tot;
}
struct Linear
{
    int k,b;
    inline Linear(int x = 1,int y = 0)
    {
        k = x,b = y;
    }
    inline Linear operator*(const Linear &o) const
    {
        return Linear((long long)k * o.k % mod,(b + (long long)k * o.b) % mod);
    }
};
struct node
{
    Linear f,g;
} seg[(N << 2) + 5];
void insert(int x,Linear f,Linear g,int p,int tl,int tr)
{
    if(tl == tr)
    {
        seg[p].f = f,seg[p].g = g;
        return ;
    }
    int mid = tl + tr >> 1;
    x <= mid ? insert(x,f,g,ls,tl,mid) : insert(x,f,g,rs,mid + 1,tr);
    seg[p].f = seg[ls].f * seg[rs].f,
    seg[p].g = seg[ls].g * seg[rs].g;
}
inline pair<Linear,Linear> operator*(const pair<Linear,Linear> &a,const pair<Linear,Linear> &b)
{
    return make_pair(a.first * b.first,a.second * b.second);
}
pair<Linear,Linear> query(int l,int r,int p,int tl,int tr)
{
    if(l <= tl && tr <= r)
        return make_pair(seg[p].f,seg[p].g);
    int mid = tl + tr >> 1;
    pair<Linear,Linear> ret;
	ret.first = Linear(),ret.second = Linear();
    l <= mid && (ret = ret * query(l,r,ls,tl,mid),1);
    r > mid && (ret = ret * query(l,r,rs,mid + 1,tr),1);
    return ret;
}
struct Value
{
    int v,cnt;
    inline Value(int x = 0)
    {
        x ? (v = x,cnt = 0) : (v = 1,cnt = 1);
    }
    inline Value(int x,int y)
    {
        v = x,cnt = y;
    }
    inline Value operator*(const Value &o) const
    {
        return Value((long long)v * o.v % mod,cnt + o.cnt);
    }
    inline Value operator/(const Value &o) const
    {
        return Value((long long)v * fpow(o.v,mod - 2) % mod,cnt - o.cnt);
    }
    inline int val()
    {
        return cnt ? 0 : v;
    }
} f[N + 5],g[N + 5];
int F[N + 5],G[N + 5];
int ans[N + 5];
int w[N + 5],W;
int fa[N + 5],dep[N + 5],sz[N + 5],son[N + 5],top[N + 5],id[N + 5],ed[N + 5];
int leaf[N + 5],pw = inv;
void dfs1(int p)
{
    sz[p] = 1;
    if(!(dep[p] & 1))
        w[p] = 0x3f3f3f3f;
    for(register int i = first[p];i;i = pre[i])
        if(to[i] ^ fa[p])
        {
            fa[to[i]] = p,dep[to[i]] = dep[p] + 1,dfs1(to[i]),sz[p] += sz[to[i]];
            if(!son[p] || sz[son[p]] < sz[to[i]])
                son[p] = to[i];
            (dep[p] & 1) ? (w[p] = max(w[p],w[to[i]])) : (w[p] = min(w[p],w[to[i]]));
        }
    if(!son[p])
        leaf[p] = 1,pw = 2LL * pw % mod,w[p] = p;
}
void dfs2(int p)
{
    static int tot = 0;
    id[p] = ++tot,F[p] = G[p] = 1,f[p] = g[p] = Value(1);
    if(son[p])
        top[son[p]] = top[p],dfs2(son[p]),ed[p] = ed[son[p]],
        F[p] = (long long)F[p] * (1 - F[son[p]] + mod) % mod,
        G[p] = (long long)G[p] * (1 - G[son[p]] + mod) % mod;
    else
        ed[p] = p,
        F[p] = p > W,G[p] = p < W,
        (dep[p] & 1) ? (F[p] = (1 - F[p] + mod) % mod) : (G[p] = (1 - G[p] + mod) % mod),
        f[p] = Value(F[p]),g[p] = Value(G[p]);
    for(register int i = first[p];i;i = pre[i])
        if(!id[to[i]])
            top[to[i]] = to[i],dfs2(to[i]),
            F[p] = (long long)F[p] * (1 - F[to[i]] + mod) % mod,
            G[p] = (long long)G[p] * (1 - G[to[i]] + mod) % mod,
            f[p] = f[p] * Value((1 - F[to[i]] + mod) % mod),
            g[p] = g[p] * Value((1 - G[to[i]] + mod) % mod);
}
void update(int x)
{
    for(;x;x = fa[x])
    {
        insert(id[x],Linear((mod - f[x].val()) % mod,f[x].val()),Linear((mod - g[x].val()) % mod,g[x].val()),1,1,n),x = top[x];
        pair<Linear,Linear> cur = query(id[x],id[ed[x]],1,1,n);
        if(fa[x])
            f[fa[x]] = f[fa[x]] / Value((1 - F[x] + mod) % mod),
            g[fa[x]] = g[fa[x]] / Value((1 - G[x] + mod) % mod);
        F[x] = cur.first.b,G[x] = cur.second.b;
        if(fa[x])
            f[fa[x]] = f[fa[x]] * Value((1 - F[x] + mod) % mod),
            g[fa[x]] = g[fa[x]] * Value((1 - G[x] + mod) % mod);
    }
}
int main()
{
    scanf("%d%d%d",&n,&L,&R);
    int u,v;
    for(register int i = 2;i <= n;++i)
        scanf("%d%d",&u,&v),add(u,v),add(v,u);
    dep[1] = top[1] = 1,dfs1(1),W = w[1],dfs2(1);
    for(register int i = 1;i <= n;++i)
        insert(id[i],Linear((mod - f[i].val()) % mod,f[i].val()),Linear((mod - g[i].val()) % mod,g[i].val()),1,1,n);
    for(register int i = 2;i < n;++i)
    {
        if(W - i + 1 > 0 && leaf[W - i + 1])
            f[W - i + 1] = Value(inv),update(W - i + 1);
        if(W + i - 1 <= n && leaf[W + i - 1])
            g[W + i - 1] = Value(inv),update(W + i - 1);
        ans[i] = (1 - (long long)F[1] * (1 - G[1] + mod) % mod + mod) * pw % mod;
    }
    ans[n] = pw - 1;
    for(register int i = 1;i <= n;++i)
        ans[i] = (ans[i] + pw) % mod;
    for(register int i = n;i;--i)
        ans[i] = (ans[i] - ans[i - 1] + mod) % mod;
    for(register int i = L;i <= R;++i)
        printf("%d%c",ans[i]," \n"[i == R]);
}