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: import java.util.*;
  import java.io.*;
  import java.text.*;
  
  public class CF_1554_E{
      //SOLUTION BEGIN
      long MOD = 998244353;
      void pre() throws Exception{}
      void solve(int TC) throws Exception{
          int N = ni();
          int[] from = new int[N-1], to = new int[N-1];
          for(int i = 0; i< N-1; i++){
              from[i] = ni()-1;
              to[i] = ni()-1;
          }
          int[][] g = make(N, N-1, from, to, true);
          long[] ans = new long[1+N];
          for(int x = N-1; x >= 2; x--){
              if((N-1)%x != 0)continue;
              ans[x] = calc(g, x)?1:0;
              for(int y = 2*x; y <= N-1; y += x){
                  ans[x] -= ans[y];
                  if(ans[x] < 0)ans[x] += MOD;
              }
          }
          ans[1] = 1;
          for(int i = 1; i<= N-1; i++)ans[1] = ans[1]*2%MOD;
          for(int j = 2; j <= N-1; j++){
              ans[1] -= ans[j];
              if(ans[1] < 0)ans[1] += MOD;
          }
          for(int i = 1; i<= N; i++)p(ans[i]);
          pn("");
      }
      boolean calc(int[][] g, int x){
          int[] val = new int[g.length];
          if(!dfs(g, val, 0, -1, x))return false;
          return val[0]%x == 0;
      }
      boolean dfs(int[][] g, int[] val, int u, int p, int x){
          boolean f = true;
          for(int v:g[u])if(v != p)f &= dfs(g, val, v, u, x);
  
          if(p == -1 || !f)return f;
          if(val[u]%x == 0){
              val[p]++;
              return true;
          }
          if((val[u]+1)%x == 0)return f;
          return false;
      }
      //SOLUTION END
      void hold(boolean b)throws Exception{if(!b)throw new Exception("Hold right there, Sparky!");}
      void exit(boolean b){if(!b)System.exit(0);}
      static void dbg(Object... o){System.err.println(Arrays.deepToString(o));}
      final long IINF = (long)1e17;
      final int INF = (int)1e9+2;
      DecimalFormat df = new DecimalFormat("0.00000000000");
      double PI = 3.141592653589793238462643383279502884197169399, eps = 1e-8;
      static boolean multipleTC = true, memory = true, fileIO = false;
      FastReader in;PrintWriter out;
      void run() throws Exception{
          long ct = System.currentTimeMillis();
          if (fileIO) {
              in = new FastReader("");
              out = new PrintWriter("");
          } else {
              in = new FastReader();
              out = new PrintWriter(System.out);
          }
          //Solution Credits: Taranpreet Singh
          int T = multipleTC? ni():1;
          pre();
          for (int t = 1; t <= T; t++) solve(t);
          out.flush();
          out.close();
          System.err.println(System.currentTimeMillis() - ct);
      }
      public static void main(String[] args) throws Exception{
          if(memory)new Thread(null, new Runnable() {public void run(){try{new CF_1554_E().run();}catch(Exception e){e.printStackTrace();System.exit(1);}}}, "1", 1 << 28).start();
          else new CF_1554_E().run();
      }
      int[][] make(int n, int e, int[] from, int[] to, boolean f){
          int[][] g = new int[n][];int[]cnt = new int[n];
          for(int i = 0; i< e; i++){
              cnt[from[i]]++;
              if(f)cnt[to[i]]++;
          }
          for(int i = 0; i< n; i++)g[i] = new int[cnt[i]];
          for(int i = 0; i< e; i++){
              g[from[i]][--cnt[from[i]]] = to[i];
              if(f)g[to[i]][--cnt[to[i]]] = from[i];
          }
          return g;
      }
      int[][][] makeS(int n, int e, int[] from, int[] to, boolean f){
          int[][][] g = new int[n][][];int[]cnt = new int[n];
          for(int i = 0; i< e; i++){
              cnt[from[i]]++;
              if(f)cnt[to[i]]++;
          }
          for(int i = 0; i< n; i++)g[i] = new int[cnt[i]][];
          for(int i = 0; i< e; i++){
              g[from[i]][--cnt[from[i]]] = new int[]{to[i], i, 0};
              if(f)g[to[i]][--cnt[to[i]]] = new int[]{from[i], i, 1};
          }
          return g;
      }
      int find(int[] set, int u){return set[u] = (set[u] == u?u:find(set, set[u]));}
      int digit(long s){int ans = 0;while(s>0){s/=10;ans++;}return ans;}
      long gcd(long a, long b){return (b==0)?a:gcd(b,a%b);}
      int gcd(int a, int b){return (b==0)?a:gcd(b,a%b);}
      int bit(long n){return (n==0)?0:(1+bit(n&(n-1)));}
      void p(Object... o){for(Object oo:o)out.print(oo+" ");}
      void pn(Object... o){for(int i = 0; i< o.length; i++)out.print(o[i]+(i+1 < o.length?" ":"\n"));}
      void pni(Object... o){for(Object oo:o)out.print(oo+" ");out.println();out.flush();}
      String n()throws Exception{return in.next();}
      String nln()throws Exception{return in.nextLine();}
      int ni()throws Exception{return Integer.parseInt(in.next());}
      long nl()throws Exception{return Long.parseLong(in.next());}
      double nd()throws Exception{return Double.parseDouble(in.next());}
  
      class FastReader{
          BufferedReader br;
          StringTokenizer st;
          public FastReader(){
              br = new BufferedReader(new InputStreamReader(System.in));
          }
  
          public FastReader(String s) throws Exception{
              br = new BufferedReader(new FileReader(s));
          }
  
          String next() throws Exception{
              while (st == null || !st.hasMoreElements()){
                  try{
                      st = new StringTokenizer(br.readLine());
                  }catch (IOException  e){
                      throw new Exception(e.toString());
                  }
              }
              return st.nextToken();
          }
  
          String nextLine() throws Exception{
              String str;
              try{
                  str = br.readLine();
              }catch (IOException e){
                  throw new Exception(e.toString());
              }
              return str;
          }
      }
  }