description: You are given a tree with n nodes. As a reminder, a tree is a connected undirected graph without cycles.
  
  Let a_1, a_2, …, a_n be a sequence of integers. Perform the following operation exactly n times: 
  
    * Select an unerased node u. Assign a_u := number of unerased nodes adjacent to u. Then, erase the node u along with all edges that have it as an endpoint. 
  
  
  
  For each integer k from 1 to n, find the number, modulo 998 244 353, of different sequences a_1, a_2, …, a_n that satisfy the following conditions:
  
    * it is possible to obtain a by performing the aforementioned operations exactly n times in some order. 
    * \operatorname{gcd}(a_1, a_2, …, a_n) = k. Here, \operatorname{gcd} means the greatest common divisor of the elements in a. 
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.
  
  The first line of each test case contains a single integer n (2 ≤ n ≤ 10^5).
  
  Each of the next n - 1 lines contains two integers u and v (1 ≤ u, v ≤ n) indicating there is an edge between vertices u and v. It is guaranteed that the given edges form a tree.
  
  It is guaranteed that the sum of n over all test cases doesn't exceed 3 ⋅ 10^5.
  
  Output
  
  For each test case, print n integers in a single line, where for each k from 1 to n, the k-th integer denotes the answer when \operatorname{gcd} equals to k.
  
  Example
  
  Input
  
  
  2
  3
  2 1
  1 3
  2
  1 2
  
  
  Output
  
  
  3 1 0
  2 0
  
  Note
  
  In the first test case, 
  
  <image>
  
    * If we delete the nodes in order 1 → 2 → 3 or 1 → 3 → 2, then the obtained sequence will be a = [2, 0, 0] which has \operatorname{gcd} equals to 2. 
    * If we delete the nodes in order 2 → 1 → 3, then the obtained sequence will be a = [1, 1, 0] which has \operatorname{gcd} equals to 1. 
    * If we delete the nodes in order 3 → 1 → 2, then the obtained sequence will be a = [1, 0, 1] which has \operatorname{gcd} equals to 1. 
    * If we delete the nodes in order 2 → 3 → 1 or 3 → 2 → 1, then the obtained sequence will be a = [0, 1, 1] which has \operatorname{gcd} equals to 1. 
  
  
  
  Note that here we are counting the number of different sequences, not the number of different orders of deleting nodes.
solution: #include <bits/stdc++.h>
  using namespace std;
  struct edge {
    long long to, cost;
    edge() {}
    edge(long long a, long long b) { to = a, cost = b; }
  };
  const long long dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
  const long long mod = 998244353;
  struct mint {
    long long x = 0;
    mint(long long y = 0) {
      x = y;
      if (x < 0 || x >= mod) x = (x % mod + mod) % mod;
    }
    mint(const mint& ope) { x = ope.x; }
    mint operator-() { return mint(-x); }
    mint operator+(const mint& ope) { return mint(x) += ope; }
    mint operator-(const mint& ope) { return mint(x) -= ope; }
    mint operator*(const mint& ope) { return mint(x) *= ope; }
    mint operator/(const mint& ope) { return mint(x) /= ope; }
    mint& operator+=(const mint& ope) {
      x += ope.x;
      if (x >= mod) x -= mod;
      return *this;
    }
    mint& operator-=(const mint& ope) {
      x += mod - ope.x;
      if (x >= mod) x -= mod;
      return *this;
    }
    mint& operator*=(const mint& ope) {
      x *= ope.x, x %= mod;
      return *this;
    }
    mint& operator/=(const mint& ope) {
      long long n = mod - 2;
      mint mul = ope;
      while (n) {
        if (n & 1) *this *= mul;
        mul *= mul;
        n >>= 1;
      }
      return *this;
    }
    mint inverse() { return mint(1) / *this; }
    bool operator==(const mint& ope) { return x == ope.x; }
    bool operator!=(const mint& ope) { return x != ope.x; }
    bool operator<(const mint& ope) { return x < ope.x; }
  };
  mint modpow(mint a, long long n) {
    if (n == 0) return mint(1);
    if (n % 2)
      return a * modpow(a, n - 1);
    else
      return modpow(a * a, n / 2);
  }
  istream& operator>>(istream& is, mint& ope) {
    long long t;
    is >> t, ope.x = t;
    return is;
  }
  ostream& operator<<(ostream& os, mint& ope) { return os << ope.x; }
  ostream& operator<<(ostream& os, const mint& ope) { return os << ope.x; }
  vector<mint> fact, fact_inv;
  void make_fact(int n) {
    fact.resize(n + 1), fact_inv.resize(n + 1);
    fact[0] = mint(1);
    for (long long i = (1); (i) <= (n); (i)++) fact[i] = fact[i - 1] * mint(i);
    fact_inv[n] = fact[n].inverse();
    for (long long i = (n - 1); (i) >= (0); (i)--)
      fact_inv[i] = fact_inv[i + 1] * mint(i + 1);
  }
  mint comb(long long n, long long k) {
    if (n < 0 || k < 0 || n < k) return mint(0);
    return fact[n] * fact_inv[k] * fact_inv[n - k];
  }
  mint perm(long long n, long long k) { return comb(n, k) * fact[k]; }
  vector<int> prime, pvec;
  void make_prime(int n) {
    prime.resize(n + 1);
    for (long long i = (2); (i) <= (n); (i)++) {
      if (prime[i]) continue;
      for (int j = i; j <= n; j += i) prime[j] = i;
    }
    for (long long i = (2); (i) <= (n); (i)++)
      if (prime[i] == i) pvec.push_back(i);
  }
  bool exceed(long long x, long long y, long long m) { return x >= m / y + 1; }
  void mark() { cout << "*" << endl; }
  void yes() { cout << "YES" << endl; }
  void no() { cout << "NO" << endl; }
  long long sgn(long long x) {
    if (x > 0) return 1;
    if (x < 0) return -1;
    return 0;
  }
  long long gcd(long long a, long long b) {
    if (b == 0) return a;
    return gcd(b, a % b);
  }
  long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
  long long digitnum(long long x, long long b = 10) {
    long long ret = 0;
    for (; x; x /= b) ret++;
    return ret;
  }
  long long digitsum(long long x, long long b = 10) {
    long long ret = 0;
    for (; x; x /= b) ret += x % b;
    return ret;
  }
  string lltos(long long x) {
    string ret;
    for (; x; x /= 10) ret += x % 10 + '0';
    reverse(ret.begin(), ret.end());
    return ret;
  }
  long long stoll(string& s) {
    long long ret = 0;
    for (auto c : s) ret *= 10, ret += c - '0';
    return ret;
  }
  template <typename T>
  void uniq(T& vec) {
    sort(vec.begin(), vec.end());
    vec.erase(unique(vec.begin(), vec.end()), vec.end());
  }
  template <class S, class T>
  pair<S, T>& operator+=(pair<S, T>& s, const pair<S, T>& t) {
    s.first += t.first, s.second += t.second;
    return s;
  }
  template <class S, class T>
  pair<S, T>& operator-=(pair<S, T>& s, const pair<S, T>& t) {
    s.first -= t.first, s.second -= t.second;
    return s;
  }
  template <class S, class T>
  pair<S, T> operator+(const pair<S, T>& s, const pair<S, T>& t) {
    return pair<S, T>(s.first + t.first, s.second + t.second);
  }
  template <class S, class T>
  pair<S, T> operator-(const pair<S, T>& s, const pair<S, T>& t) {
    return pair<S, T>(s.first - t.first, s.second - t.second);
  }
  template <typename T>
  ostream& operator<<(ostream& os, vector<T>& vec) {
    for (int i = 0; i < vec.size(); i++)
      os << vec[i] << (i + 1 == vec.size() ? "" : " ");
    return os;
  }
  template <typename T>
  ostream& operator<<(ostream& os, deque<T>& deq) {
    for (int i = 0; i < deq.size(); i++)
      os << deq[i] << (i + 1 == deq.size() ? "" : " ");
    return os;
  }
  template <typename T, typename U>
  ostream& operator<<(ostream& os, pair<T, U>& pair_var) {
    os << "(" << pair_var.first << ", " << pair_var.second << ")";
    return os;
  }
  template <typename T, typename U>
  ostream& operator<<(ostream& os, const pair<T, U>& pair_var) {
    os << "(" << pair_var.first << ", " << pair_var.second << ")";
    return os;
  }
  template <typename T, typename U>
  ostream& operator<<(ostream& os, map<T, U>& map_var) {
    for (typename map<T, U>::iterator itr = map_var.begin(); itr != map_var.end();
         itr++) {
      os << "(" << itr->first << ", " << itr->second << ")";
      itr++;
      if (itr != map_var.end()) os << ",";
      itr--;
    }
    return os;
  }
  template <typename T>
  ostream& operator<<(ostream& os, set<T>& set_var) {
    for (typename set<T>::iterator itr = set_var.begin(); itr != set_var.end();
         itr++) {
      os << *itr;
      ++itr;
      if (itr != set_var.end()) os << " ";
      itr--;
    }
    return os;
  }
  template <typename T>
  ostream& operator<<(ostream& os, multiset<T>& set_var) {
    for (typename multiset<T>::iterator itr = set_var.begin();
         itr != set_var.end(); itr++) {
      os << *itr;
      ++itr;
      if (itr != set_var.end()) os << " ";
      itr--;
    }
    return os;
  }
  template <typename T>
  void outa(T a[], long long s, long long t) {
    for (long long i = s; i <= t; i++) {
      cout << a[i];
      if (i < t) cout << " ";
    }
    cout << endl;
  }
  void dump_func() { cout << endl; }
  template <class Head, class... Tail>
  void dump_func(Head&& head, Tail&&... tail) {
    cout << head;
    if (sizeof...(Tail) > 0) cout << " ";
    dump_func(std::move(tail)...);
  }
  long long T;
  long long n;
  vector<long long> G[100005];
  long long sum[100005];
  long long cnt[100005];
  mint dp[100005];
  vector<long long> dvec[200005];
  void dfs(int v, int p) {
    sum[v] += ((long long)(G[v]).size());
    for (auto u : G[v]) {
      if (u == p) continue;
      dfs(u, v);
      sum[v] += sum[u];
    }
  }
  void dfs2(int v, int p) {
    for (auto u : G[v]) {
      if (u == p) continue;
      long long S = sum[u], T = sum[1] - sum[u];
      long long g = gcd(S - 1, T + 1), h = gcd(S + 1, T - 1);
      vector<long long> vec = dvec[g];
      vec.insert(vec.end(), (dvec[h]).begin(), (dvec[h]).end());
      uniq(vec);
      for (auto x : vec)
        if (x <= n) cnt[x]++;
      dfs2(u, v);
    }
  }
  long long deg[100005];
  bool dfs3(int v, int p, int g) {
    if (sum[v] == 1) return false;
    for (auto u : G[v]) {
      if (u == p) continue;
      if (dfs3(u, v, g)) deg[v]++;
    }
    bool ret = true;
    if (p != -1 && (deg[v] + 1) % g == ((long long)(G[v]).size()) % g)
      ret = false, deg[v]++;
    else if (deg[v] % g != ((long long)(G[v]).size()) % g)
      cnt[g] = 0;
    return ret;
  }
  int main(void) {
    ios::sync_with_stdio(0);
    cin.tie(0);
    for (long long i = (1); (i) <= (200003); (i)++) {
      for (int j = i; j <= 200003; j += i) dvec[j].push_back(i);
    }
    cin >> T;
    while (T--) {
      cin >> n;
      long long u, v;
      for (long long i = (1); (i) <= (n); (i)++) G[i].clear();
      for (long long i = (1); (i) <= (n - 1); (i)++) {
        cin >> u >> v;
        G[u].push_back(v);
        G[v].push_back(u);
      }
      for (long long i = (1); (i) <= (n); (i)++) sum[i] = cnt[i] = 0;
      dfs(1, -1), dfs2(1, -1);
      for (long long i = (1); (i) <= (n); (i)++) dp[i] = 0;
      for (long long i = (2); (i) <= (n); (i)++) {
        if (cnt[i] == n - 1) {
          for (long long j = (1); (j) <= (n); (j)++) deg[j] = 0;
          dfs3(1, -1, i);
          if (cnt[i] == n - 1) dp[i] = 1;
        }
      }
      dp[1] = modpow(mint(2), n - 1);
      for (long long i = (n); (i) >= (1); (i)--)
        for (int j = 2 * i; j <= n; j += i) dp[i] -= dp[j];
      outa(dp, 1, n);
    }
    return 0;
  }
  