#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std;
using mint = atcoder::modint998244353;

template <class T> struct csr {
    using itr = typename std::vector<T>::iterator;
    struct Node {
        itr st, en;
        itr begin() { return st; }
        itr end() { return en; }
        int size() { return en - st; }
        T operator[](int p){ return st[p]; }
    };
    const int N;
    std::vector<int> start;
    std::vector<T> E;
    std::vector<std::pair<int,T>> edge;
    csr(int n) : N(n), start(n + 1) {}
    void add_edge(int u, T v){
        assert(0 <= u && u < N);
        start[u + 1]++;
        edge.emplace_back(u, v);
    }
    void build(){
        E.resize(edge.size());
        for(int i = 0; i < N; i++) start[i + 1] += start[i];
        auto cnt = start;
        for(auto [u, v] : edge) E[cnt[u]++] = v;
    }
    Node operator[](int p) {
        return Node{E.begin() + start[p], E.begin() + start[p + 1]};
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, s, t, u, v, st, gl;
    cin >> n >> s >> t;
    s--, t--;
    csr<pair<int,int>> g(n);
    for(int i = 0; i + 1 < n; i++){
        cin >> u >> v;
        u--, v--;
        g.add_edge(u, {v, i});
        g.add_edge(v, {u, i});
        if(i == s) st = u, gl = v;
    }
    g.build();

    vector<mint> fact(n + 1), inv(n + 1);
    fact[0] = 1;
    for(int i = 1; i <= n; i++) fact[i] = mint::raw(i) * fact[i - 1];
    inv[n] = fact[n].inv();
    for(int i = n; i >= 1; i--) inv[i - 1] = mint::raw(i) * inv[i];

    vector<vector<mint>> tb;
    auto dfs = [&](auto dfs, int v, int p) -> bool {
        for(auto [u, ei] : g[v]){
            if(u == p) continue;
            if(ei == t || dfs(dfs, u, v)){
                int add = g[v].size() - 2;
                tb.emplace_back(vector<mint>(add + 1));
                for(int i = 0; i <= add; i++){
                    tb.back()[i] = fact[add] * inv[add - i];
                }
                return true;
            }
        }
        return false;
    };
    if(!dfs(dfs, st, gl)){
        dfs(dfs, gl, st);
    }
    queue<int> que;
    u = 0;
    for(int i = 0; i < tb.size(); i++) que.emplace(i);
    while(que.size() >= 2){
        u = que.front();
        que.pop();
        v = que.front();
        que.pop();
        tb[u] = atcoder::convolution(tb[u], tb[v]);
        que.emplace(u);
    }
    int mn = tb.size() + 1;
    for(int i = 1; i <= n; i++){
        if(i < mn){
            cout << '0';
        }else if(i - mn < tb[u].size()){
            cout << tb[u][i - mn].val();
        }else{
            cout << '0';
        }
        cout << (i == n ? '\n' : ' ');
    }
}