```go
package main

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

const MOD int64 = 998244353

func powmod(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.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

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

	if k < 0 || k > n-1 {
		fmt.Fprintln(out, 0)
		return
	}

	// Precompute factorials and inverse factorials up to n
	fac := make([]int64, n+1)
	ifac := make([]int64, n+1)
	fac[0] = 1
	for i := 1; i <= n; i++ {
		fac[i] = fac[i-1] * int64(i) % MOD
	}
	ifac[n] = powmod(fac[n], MOD-2)
	for i := n - 1; i >= 0; i-- {
		ifac[i] = ifac[i+1] * int64(i+1) % MOD
	}

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

	// Precompute i^n for i=0..n
	powN := make([]int64, n+1)
	for i := 0; i <= n; i++ {
		powN[i] = powmod(int64(i), int64(n))
	}

	m := n - k // number of non-empty columns (or rows) in the two cases

	F := func(m int) int64 {
		var sum int64 = 0
		for j := 0; j <= m; j++ {
			c := comb(m, j)
			val := powN[m-j]
			term := c * val % MOD
			if j&1 == 1 {
				sum -= term
				if sum < 0 {
					sum += MOD
				}
			} else {
				sum += term
				if sum >= MOD {
					sum -= MOD
				}
			}
		}
		return sum
	}

	Fm := F(m)
	T := comb(n, m) * Fm % MOD
	ans := (2 * T) % MOD
	if k == 0 {
		ans -= Fm
		if ans < 0 {
			ans += MOD
		}
	}
	fmt.Fprintln(out, ans%MOD)
}
```