package main

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

const MOD = 998244353
const MAX = 300005

var fact [MAX]int64
var invFact [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
	invFact[0] = 1
	for i := 1; i < MAX; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
	}
	invFact[MAX-1] = modInverse(fact[MAX-1])
	for i := MAX - 2; i >= 1; i-- {
		invFact[i] = (invFact[i+1] * int64(i+1)) % MOD
	}
}

func nCr(n, k int) int64 {
	if k < 0 || k > n {
		return 0
	}
	return fact[n] * invFact[k] % MOD * invFact[n-k] % MOD
}

func C(m, k int) int64 {
	if m < 0 {
		return 0
	}
	var res int64 = 0
	limit := m / 3
	for i := 0; i <= limit; i++ {
		if i > k-1 {
			break
		}
		term := (nCr(k-1, i) * nCr(m-3*i+k-2, k-2)) % MOD
		if i%2 == 1 {
			res = (res - term + MOD) % MOD
		} else {
			res = (res + term) % MOD
		}
	}
	return res
}

func f(v int64) int64 {
	return (v * (v - 1)) / 2
}

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 t > 0 {
		t--
		var n, k int
		fmt.Fscan(reader, &n, &k)

		v := int64(n) / int64(2*k)
		R := n % (2 * k)

		var minInc int64
		var ways int64

		if v == 0 {
			minInc = 0
			ways = nCr(k-1, n-k-1)
		} else {
			minInc = int64(2*k-R)*f(v) + int64(R)*f(v+1)
			if k == 1 {
				if R == 0 {
					ways = 1
				} else {
					ways = 2
				}
			} else {
				ways = (C(R, k) + 2*C(R-1, k) + C(R-2, k)) % MOD
			}
		}

		fmt.Fprintln(writer, minInc, ways)
	}
}