```go
package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"sort"
)

const MOD int64 = 998244353

func readAll() []byte {
	data, _ := io.ReadAll(os.Stdin)
	return data
}

type Reader struct {
	data []byte
	pos  int
	n    int
}

func NewReader() *Reader {
	d := readAll()
	return &Reader{data: d, pos: 0, n: len(d)}
}

func (r *Reader) nextInt() int {
	n := r.n
	data := r.data
	pos := r.pos

	for pos < n && (data[pos] < '0' || data[pos] > '9') && data[pos] != '-' {
		pos++
	}
	sign := 1
	if pos < n && data[pos] == '-' {
		sign = -1
		pos++
	}
	val := 0
	for pos < n && data[pos] >= '0' && data[pos] <= '9' {
		val = val*10 + int(data[pos]-'0')
		pos++
	}
	r.pos = pos
	return val * sign
}

func getDivisors(x int) []int {
	ds := []int{}
	for i := 1; i*i <= x; i++ {
		if x%i == 0 {
			ds = append(ds, i)
			if i*i != x {
				ds = append(ds, x/i)
			}
		}
	}
	sort.Ints(ds)
	return ds
}

func main() {
	in := NewReader()
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	t := in.nextInt()

	maxN := 300000 + 5
	pow2 := make([]int64, maxN)
	pow2[0] = 1
	for i := 1; i < maxN; i++ {
		pow2[i] = (pow2[i-1] * 2) % MOD
	}

	for ; t > 0; t-- {
		n := in.nextInt()
		adj := make([][]int, n+1)
		for i := 0; i < n-1; i++ {
			u := in.nextInt()
			v := in.nextInt()
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}

		// Build parent and order once
		parent := make([]int, n+1)
		order := make([]int, 0, n)
		stack := []int{1}
		parent[1] = -1
		for len(stack) > 0 {
			u := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			order = append(order, u)
			for _, v := range adj[u] {
				if v == parent[u] || parent[v] != 0 {
					continue
				}
				parent[v] = u
				stack = append(stack, v)
			}
		}

		g := make([]int64, n+1)
		g[1] = pow2[n-1]

		ds := getDivisors(n - 1)
		ok := make([]bool, n+1)
		isZero := make([]bool, n+1)

		for _, k := range ds {
			if k == 1 {
				continue
			}
			// DP per k
			for i := range ok {
				ok[i] = false
				isZero[i] = false
			}
			valid := true
			for i := n - 1; i >= 0; i-- {
				u := order[i]
				s := 0
				okU := true
				for _, v := range adj[u] {
					if v == parent[u] {
						continue
					}
					if !ok[v] {
						okU = false
						break
					}
					if isZero[v] {
						s++
					}
				}
				if !okU {
					ok[u] = false
					continue
				}
				r := s % k
				if r == 0 {
					ok[u] = true
					isZero[u] = true
				} else if r == k-1 {
					ok[u] = true
					isZero[u] = false
				} else {
					ok[u] = false
				}
			}
			if !(ok[1] && isZero[1]) {
				valid = false
			}
			if valid {
				g[k] = 1
			} else {
				g[k] = 0
			}
		}

		ans := make([]int64, n+1)
		for k := n; k >= 1; k-- {
			res := g[k]
			for m := 2; k*m <= n; m++ {
				res -= ans[k*m]
			}
			res %= MOD
			if res < 0 {
				res += MOD
			}
			ans[k] = res
		}

		for k := 1; k <= n; k++ {
			if k > 1 {
				fmt.Fprint(out, " ")
			}
			fmt.Fprint(out, ans[k]%MOD)
		}
		fmt.Fprintln(out)
	}
}
```