```go
package main

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

const MOD = 998244353
const MAXM = 100005

var primes []int
var isPrime [MAXM]bool
var mu [MAXM]int
var divs [MAXM][]int

func precompute() {
	for i := 2; i < MAXM; i++ {
		isPrime[i] = true
	}
	mu[1] = 1
	for i := 2; i < MAXM; i++ {
		if isPrime[i] {
			primes = append(primes, i)
			mu[i] = -1
		}
		for _, p := range primes {
			if i*p >= MAXM {
				break
			}
			isPrime[i*p] = false
			if i%p == 0 {
				mu[i*p] = 0
				break
			} else {
				mu[i*p] = -mu[i]
			}
		}
	}
	for i := 1; i < MAXM; i++ {
		for j := i; j < MAXM; j += i {
			divs[j] = append(divs[j], i)
		}
	}
}

var DP [MAXM]int
var T [MAXM]int
var add_to_DP [MAXM]int
var S [MAXM]int

func main() {
	precompute()

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

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for i := 0; i < t; i++ {
		var m int
		fmt.Fscan(reader, &m)

		Ans := 0

		for y := m; y >= 1; y-- {
			D := divs[y]

			for _, gp := range D {
				sum := 0
				k := y / gp
				for _, d := range divs[k] {
					if mu[d] == 1 {
						x := d * gp
						sum += T[x]
						if sum >= MOD {
							sum -= MOD
						}
					} else if mu[d] == -1 {
						x := d * gp
						sum -= T[x]
						if sum < 0 {
							sum += MOD
						}
					}
				}
				S[gp] = sum
			}

			for _, gp := range D {
				delta := S[gp] - DP[gp]
				if delta < 0 {
					delta += MOD
				}
				add_to_DP[gp] = (2 * delta) % MOD
			}

			add_to_DP[y] += 1
			if add_to_DP[y] >= MOD {
				add_to_DP[y] -= MOD
			}

			for _, gp := range D {
				if add_to_DP[gp] > 0 {
					val := add_to_DP[gp]
					Ans += val
					if Ans >= MOD {
						Ans -= MOD
					}
					DP[gp] += val
					if DP[gp] >= MOD {
						DP[gp] -= MOD
					}

					for _, x := range divs[gp] {
						T[x] += val
						if T[x] >= MOD {
							T[x] -= MOD
						}
					}
					add_to_DP[gp] = 0
				}
			}
		}

		fmt.Fprintln(writer, Ans)

		for j := 1; j <= m; j++ {
			DP[j] = 0
			T[j] = 0
		}
	}
}
```