#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<utility>
#include<tuple>
#include<cstdint>
#include<cstdio>
#include<iomanip>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<deque>
#include<unordered_map>
#include<unordered_set>
#include<bitset>
#include<cctype>
#include<chrono>
#include<random>
#include<cassert>
#include<cstddef>
#include<iterator>
#include<string_view>
#include<type_traits>

#ifdef LOCAL
#  include "debug_print.hpp"
#  define debug(...) debug_print::multi_print(#__VA_ARGS__, __VA_ARGS__)
#else
#  define debug(...) (static_cast<void>(0))
#endif

using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define rrep(i,n) for(int i=(n)-1; i>=0; i--)
#define FOR(i,a,b) for(int i=(a); i<(b); i++)
#define RFOR(i,a,b) for(int i=(b-1); i>=(a); i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
#define pb push_back
using ll = long long;
using D = double;
using LD = long double;
using P = pair<int, int>;
template<typename T> using PQ = priority_queue<T,vector<T>>;
template<typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
void yesno(bool flag) {cout << (flag?"Yes":"No") << "\n";}

template<typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
    os << p.first << " " << p.second;
    return os;
}
template<typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
    is >> p.first >> p.second;
    return is;
}

template<typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    int s = (int)v.size();
    for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
    return os;
}
template<typename T>
istream &operator>>(istream &is, vector<T> &v) {
    for (auto &x : v) is >> x;
    return is;
}
void in() {}
template<typename T, class... U>
void in(T &t, U &...u) {
    cin >> t;
    in(u...);
}
void out() { cout << "\n"; }
template<typename T, class... U, char sep = ' '>
void out(const T &t, const U &...u) {
    cout << t;
    if (sizeof...(u)) cout << sep;
    out(u...);
}
void outr() {}
template<typename T, class... U, char sep = ' '>
void outr(const T &t, const U &...u) {
    cout << t;
    outr(u...);
}

#include "atcoder/modint.hpp"
using mint = atcoder::modint998244353;


const int MAX_N = 200005;
int c[MAX_N];
mint ci[MAX_N];

struct edge{
    int from;
    int to;
    int fi;
    int ti;
};

edge rd[MAX_N*2];

struct var {
    mint dp;
    var(mint dp=0) : dp(dp){}
    var merge (const var& a, const mint d, const int v, const int vi, const int vo) const {
        mint delta = d * a.dp;
        if (vi != -1 and vo != -1 and vi <= vo){
            delta *= ci[v];
        }
        return {dp + delta};
    }
    var addRoot() const {
        return {dp+1};
    }
};


vector<tuple<int,int,mint>> g[MAX_N];
vector<var> dp[MAX_N];
var ans[MAX_N];

var dfs1(int v, int pv = -1, int pi = -1) {
    var dpsum;
    dp[v] = vector<var> (g[v].size());

    rep(i, g[v].size()) {
        auto [u, ei, d] = g[v][i];
        if(u == pv) continue;
        dp[v][i] = dfs1(u, v, ei);
        dpsum = dpsum.merge(dp[v][i], d, v, pi, i);
    }
    return dpsum.addRoot();
}

void dfs2(int v, const var& dpParent = var(), int pv = -1, int pi = -1) {
    int deg = g[v].size();
    rep(i, deg) {
        auto [u, ei, d] = g[v][i];
        if (u == pv) {
            auto tmp = var{0};
            rep(j, g[u].size()){
                auto [w, ej, dj] = g[u][j];
                if(w == v) continue;
                tmp = tmp.merge(dp[u][j], dj, u, ei, j);
            }
            dp[v][i] = var{tmp}.addRoot();
        }
    }

    vector<var> dpSum_Left(deg+1), dpSum_Right(deg+1);
    rep(i,deg) {
        auto [u, ei, d] = g[v][i];
        dpSum_Left[i+1] = dpSum_Left[i].merge(dp[v][i], d, v,-1,-1);
    }
    rrep(i, deg) {
        auto [u, ei, d] = g[v][i];
        dpSum_Right[i] = dpSum_Right[i+1].merge(dp[v][i], d, v,-1,-1);
    }

    ans[v] = dpSum_Left[deg].addRoot();

    rep(i,deg) {
        auto [u, ei, d] = g[v][i];
        if(u == pv) continue;
        var np{dpSum_Left[i].dp + dpSum_Right[i+1].dp};

        dfs2(u, np.addRoot(), v, -1);
    }
}

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; in(n);
    rep(i,2*n-2) rd[i] = {-1,-1,-1,-1};
    rep(i,n){
        in(c[i]);
        rep(j,c[i]){
            int eij; in(eij); eij--;
            if(rd[2*eij].from == -1) rd[2*eij].from = i, rd[2*eij].fi = j;
            else rd[2*eij].to = i, rd[2*eij].ti = j;
        }
        c[i]++;
    }
    rep(i,n-1){
        auto [x,y,z,w] = rd[2*i];
        rd[2*i+1] = {y,x,w,z};
    }

    rep(i,n) g[i].assign(c[i]-1,{0,0,0});
    rep(i,2*n-2){
        auto [x,y,z,w] = rd[i];
        mint d = mint(x+1).pow(z+1) * mint(y+1).pow(c[y]-w-1);
        g[x][z] = {y,w,d};
    }


    rep(i,n) ci[i] = mint(i+1).inv().pow(c[i]);

    dfs1(0);
    dfs2(0);

    rep(i,n) out((ans[i].dp-1).val());
}