```go
package main

import (
	"fmt"
)

const MOD = 998244353

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 main() {
	var n, k int
	if _, err := fmt.Scan(&n, &k); err != nil {
		return
	}

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

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

	F := make([]int64, 4*n+1)
	F2 := make([]int64, 4*n+1)
	F3 := make([]int64, 4*n+1)
	F4 := make([]int64, 4*n+1)
	S := make([]int64, 4*n+1)

	F[n] = 1
	F2[2*n] = 1
	F3[3*n] = 1
	F4[4*n] = 1
	S[4*n] = 1

	for x := n - 1; x >= 1; x-- {
		c := nCr(n, x)
		c2 := (c * c) % MOD
		c3 := (c2 * c) % MOD
		c4 := (c3 * c) % MOD

		c4_3 := (4 * c) % MOD
		c6_2 := (6 * c2) % MOD
		c4_1 := (4 * c3) % MOD

		c3_2 := (3 * c) % MOD
		c3_1 := (3 * c2) % MOD

		c2_1 := (2 * c) % MOD

		for i := 4 * n; i >= 0; i-- {
			new_F4 := F4[i]
			if i-x >= 0 {
				new_F4 = (new_F4 + F3[i-x]*c4_3) % MOD
			}
			if i-2*x >= 0 {
				new_F4 = (new_F4 + F2[i-2*x]*c6_2) % MOD
			}
			if i-3*x >= 0 {
				new_F4 = (new_F4 + F[i-3*x]*c4_1) % MOD
			}
			if i == 4*x {
				new_F4 = (new_F4 + c4) % MOD
			}
			F4[i] = new_F4
		}

		for i := 3 * n; i >= 0; i-- {
			new_F3 := F3[i]
			if i-x >= 0 {
				new_F3 = (new_F3 + F2[i-x]*c3_2) % MOD
			}
			if i-2*x >= 0 {
				new_F3 = (new_F3 + F[i-2*x]*c3_1) % MOD
			}
			if i == 3*x {
				new_F3 = (new_F3 + c3) % MOD
			}
			F3[i] = new_F3
		}

		for i := 2 * n; i >= 0; i-- {
			new_F2 := F2[i]
			if i-x >= 0 {
				new_F2 = (new_F2 + F[i-x]*c2_1) % MOD
			}
			if i == 2*x {
				new_F2 = (new_F2 + c2) % MOD
			}
			F2[i] = new_F2
		}

		for i := n; i >= 0; i-- {
			new_F := F[i]
			if i == x {
				new_F = (new_F + c) % MOD
			}
			F[i] = new_F
		}

		for i := 0; i <= 4*n; i++ {
			S[i] = (S[i] + F4[i]) % MOD
		}
	}

	ans := int64(0)
	for w := 0; w <= 4*n-1; w++ {
		term1 := (S[w] * modInverse(nCr(4*n, w))) % MOD
		num := (int64(n) - term1 + MOD) % MOD
		den := int64(4*n - w)
		E_w := (num * modInverse(den)) % MOD

		count := int64(0)
		if w < k {
			count = 1
		} else if w == k {
			count = int64(4*n - k)
		} else {
			count = 0
		}

		ans = (ans + count*E_w) % MOD
	}

	fmt.Println(ans)
}
```