```go
package main

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

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

	var t int
	fmt.Fscan(reader, &t)

	for ; t > 0; t-- {
		var n, k int
		fmt.Fscan(reader, &n, &k)

		a := make([][]int, n)
		for i := 0; i < n; i++ {
			a[i] = make([]int, n)
			for j := 0; j < n; j++ {
				fmt.Fscan(reader, &a[i][j])
			}
		}

		// For 180 degree rotation, cell (i,j) must equal cell (n-1-i, n-1-j)
		// Count minimum number of changes needed
		minChanges := 0
		for i := 0; i < n; i++ {
			for j := 0; j < n; j++ {
				ri := n - 1 - i
				rj := n - 1 - j
				if i < ri || (i == ri && j < rj) {
					if a[i][j] != a[ri][rj] {
						minChanges++
					}
				}
			}
		}

		// If n is odd, the center cell (n/2, n/2) is paired with itself, no change needed for it
		// But we can use it to adjust parity

		// We need exactly k operations. minChanges is the minimum.
		// After using minChanges, we have k - minChanges remaining.
		// If n is odd, the center cell can be toggled back and forth, so any remaining >= 0 works
		// (we can waste operations on the center cell)
		// If n is even, remaining operations must be even (toggle any cell back and forth)

		if k < minChanges {
			fmt.Fprintln(writer, "NO")
		} else {
			remaining := k - minChanges
			if n%2 == 1 {
				// Center cell can absorb any extra operation (toggle it)
				// Actually even with center, we can always use remaining ops:
				// if remaining is even, do nothing extra or toggle any pair
				// if remaining is odd, toggle center cell once
				fmt.Fprintln(writer, "YES")
			} else {
				// No center cell, so remaining must be even
				if remaining%2 == 0 {
					fmt.Fprintln(writer, "YES")
				} else {
					fmt.Fprintln(writer, "NO")
				}
			}
		}
	}
}
```