package main

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

const MOD = 998244353
const MAX = 600005

var fact [MAX]int64
var inv_fact [MAX]int64

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

func modInverse(n int64) int64 {
	return power(n, MOD-2)
}

func precompute() {
	fact[0] = 1
	inv_fact[0] = 1
	for i := 1; i < MAX; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
	}
	inv_fact[MAX-1] = modInverse(fact[MAX-1])
	for i := MAX - 2; i >= 1; i-- {
		inv_fact[i] = (inv_fact[i+1] * int64(i+1)) % MOD
	}
}

func C(k int) int64 {
	if k < 0 {
		return 0
	}
	res := fact[2*k]
	res = (res * inv_fact[k]) % MOD
	res = (res * inv_fact[k+1]) % MOD
	return res
}

func invC(k int) int64 {
	if k < 0 {
		return 0
	}
	res := fact[k]
	res = (res * fact[k+1]) % MOD
	res = (res * inv_fact[2*k]) % MOD
	return res
}

type Interval struct {
	id int
	l  int
	r  int
}

func readInt(reader *bufio.Reader) int {
	b, err := reader.ReadByte()
	for err == nil && (b == ' ' || b == '\n' || b == '\r' || b == '\t') {
		b, err = reader.ReadByte()
	}
	res := 0
	for err == nil && b >= '0' && b <= '9' {
		res = res*10 + int(b-'0')
		b, err = reader.ReadByte()
	}
	return res
}

func main() {
	precompute()

	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	b, _ := reader.Peek(1)
	if len(b) == 0 {
		return
	}

	t := readInt(reader)

	for tc := 0; tc < t; tc++ {
		n := readInt(reader)

		arr := make([]Interval, n+1)
		arr[0] = Interval{0, 0, 2*n + 1}
		for i := 1; i <= n; i++ {
			l := readInt(reader)
			r := readInt(reader)
			arr[i] = Interval{i, l, r}
		}

		sort.Slice(arr, func(i, j int) bool {
			if arr[i].l != arr[j].l {
				return arr[i].l < arr[j].l
			}
			return arr[i].r > arr[j].r
		})

		R_val := make([]int, n+1)
		for i := 0; i <= n; i++ {
			R_val[arr[i].id] = arr[i].r
		}

		parent := make([]int, n+1)
		st := make([]int, 0, n+1)
		st = append(st, arr[0].id)

		for i := 1; i <= n; i++ {
			for len(st) > 0 && R_val[st[len(st)-1]] < arr[i].r {
				st = st[:len(st)-1]
			}
			parent[arr[i].id] = st[len(st)-1]
			st = append(st, arr[i].id)
		}

		m := make([]int, n+1)
		for i := 0; i <= n; i++ {
			length := arr[i].r - arr[i].l + 1
			m[arr[i].id] = (length - 2) / 2
		}

		for i := 1; i <= n; i++ {
			u := arr[i].id
			p := parent[u]
			length := arr[i].r - arr[i].l + 1
			m[p] -= length / 2
		}

		ways := int64(1)
		for i := 0; i <= n; i++ {
			ways = (ways * C(m[i])) % MOD
		}

		ans := make([]int64, n+1)
		ans[n] = ways

		dsu_parent := make([]int, n+1)
		for i := 0; i <= n; i++ {
			dsu_parent[i] = i
		}

		find_set := func(v int) int {
			root := v
			for root != dsu_parent[root] {
				root = dsu_parent[root]
			}
			curr := v
			for curr != root {
				nxt := dsu_parent[curr]
				dsu_parent[curr] = root
				curr = nxt
			}
			return root
		}

		for i := n; i >= 1; i-- {
			u := i
			p := find_set(parent[u])

			ways = (ways * invC(m[p])) % MOD
			ways = (ways * invC(m[u])) % MOD

			m[p] += m[u] + 1

			ways = (ways * C(m[p])) % MOD

			dsu_parent[u] = p

			ans[i-1] = ways
		}

		for i := 0; i <= n; i++ {
			if i > 0 {
				fmt.Fprint(writer, " ")
			}
			fmt.Fprint(writer, ans[i])
		}
		fmt.Fprintln(writer)
	}
}