```go
package main

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

const MOD int64 = 998244353

func modPow(a, e int64) int64 {
	res := int64(1)
	for e > 0 {
		if e&1 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return res
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	var n, k int
	fmt.Fscan(in, &n, &k)

	N := 4 * n
	maxM := k
	if maxM > N-1 {
		maxM = N - 1
	}

	fact := make([]int64, N+1)
	invFact := make([]int64, N+1)
	fact[0] = 1
	for i := 1; i <= N; i++ {
		fact[i] = fact[i-1] * int64(i) % MOD
	}
	invFact[N] = modPow(fact[N], MOD-2)
	for i := N; i >= 1; i-- {
		invFact[i-1] = invFact[i] * int64(i) % MOD
	}

	comb := func(nn, rr int) int64 {
		if rr < 0 || rr > nn {
			return 0
		}
		return fact[nn] * invFact[rr] % MOD * invFact[nn-rr] % MOD
	}

	invSmall := make([]int64, N+1)
	if N >= 1 {
		invSmall[1] = 1
	}
	for i := 2; i <= N; i++ {
		invSmall[i] = MOD - (MOD/int64(i))*invSmall[int(MOD%int64(i))]%MOD
	}

	chooseN := make([]int64, n+1)
	for i := 0; i <= n; i++ {
		chooseN[i] = comb(n, i)
	}

	A := make([]int64, maxM+1)
	P2 := make([]int64, maxM+1)
	P3 := make([]int64, maxM+1)
	P4 := make([]int64, maxM+1)
	NA := make([]int64, maxM+1)
	NP2 := make([]int64, maxM+1)
	NP3 := make([]int64, maxM+1)
	NP4 := make([]int64, maxM+1)
	sumCount := make([]int64, maxM+1)
	invChoose := make([]int64, maxM+1)

	invFactN := invFact[N]
	for m := 0; m <= maxM; m++ {
		if m <= n {
			A[m] = chooseN[m]
		}
		if m <= 2*n {
			P2[m] = comb(2*n, m)
		}
		if m <= 3*n {
			P3[m] = comb(3*n, m)
		}
		P4[m] = comb(N, m)
		invChoose[m] = invFactN * fact[m] % MOD * fact[N-m] % MOD
	}

	for r := 0; r < n; r++ {
		s := r
		c := chooseN[r]
		c2 := c * c % MOD
		c3 := c2 * c % MOD
		c4 := c2 * c2 % MOD
		m2c := 2 * c % MOD
		m3c := 3 * c % MOD
		m4c := 4 * c % MOD
		m3c2 := 3 * c2 % MOD
		m6c2 := 6 * c2 % MOD
		m4c3 := 4 * c3 % MOD

		for m := 0; m <= maxM; m++ {
			vA := A[m]
			if m == s {
				vA -= c
				if vA < 0 {
					vA += MOD
				}
			}
			NA[m] = vA

			v2 := P2[m]
			if m >= s {
				v2 -= m2c * A[m-s] % MOD
			}
			if m == 2*s {
				v2 += c2
			}
			v2 %= MOD
			if v2 < 0 {
				v2 += MOD
			}
			NP2[m] = v2

			v3 := P3[m]
			if m >= s {
				v3 -= m3c * P2[m-s] % MOD
			}
			if m >= 2*s {
				v3 += m3c2 * A[m-2*s] % MOD
			}
			if m == 3*s {
				v3 -= c3
			}
			v3 %= MOD
			if v3 < 0 {
				v3 += MOD
			}
			NP3[m] = v3

			v4 := P4[m]
			if m >= s {
				v4 -= m4c * P3[m-s] % MOD
			}
			if m >= 2*s {
				v4 += m6c2 * P2[m-2*s] % MOD
			}
			if m >= 3*s {
				v4 -= m4c3 * A[m-3*s] % MOD
			}
			if m == 4*s {
				v4 += c4
			}
			v4 %= MOD
			if v4 < 0 {
				v4 += MOD
			}
			NP4[m] = v4
		}

		A, NA = NA, A
		P2, NP2 = NP2, P2
		P3, NP3 = NP3, P3
		P4, NP4 = NP4, P4

		for m := 0; m <= maxM; m++ {
			x := sumCount[m] + P4[m]
			if x >= MOD {
				x -= MOD
			}
			sumCount[m] = x
		}
	}

	eMin := make([]int64, maxM+1)
	for m := 0; m <= maxM; m++ {
		eMin[m] = sumCount[m] * invChoose[m] % MOD
	}

	ans := int64(0)
	nMod := int64(n) % MOD

	if k < N {
		for m := 0; m < k; m++ {
			val := nMod - eMin[m]
			if val < 0 {
				val += MOD
			}
			ans += val * invSmall[N-m] % MOD
			if ans >= MOD {
				ans -= MOD
			}
		}
		tail := nMod - eMin[k]
		if tail < 0 {
			tail += MOD
		}
		ans += tail
		ans %= MOD
	} else {
		for m := 0; m < N; m++ {
			val := nMod - eMin[m]
			if val < 0 {
				val += MOD
			}
			ans += val * invSmall[N-m] % MOD
			ans %= MOD
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprintln(out, ans)
	out.Flush()
}
```