```go
package main

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

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

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

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

	// Find the empty cell
	emptyRow, emptyCol := -1, -1
	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			if grid[i][j] == 0 {
				emptyRow, emptyCol = i, j
			}
		}
	}

	// Special case n=1
	if n == 1 {
		fmt.Fprintln(writer, 1)
		return
	}

	// Calculate row sums, col sums, diag sums
	rowSums := make([]int64, n)
	colSums := make([]int64, n)
	var diag1, diag2 int64

	for i := 0; i < n; i++ {
		for j := 0; j < n; j++ {
			rowSums[i] += grid[i][j]
			colSums[j] += grid[i][j]
		}
		diag1 += grid[i][i]
		diag2 += grid[i][n-1-i]
	}

	// Determine target sum
	// The empty cell is at (emptyRow, emptyCol)
	// We need to find x such that all rows, cols, diags are equal

	// Find a row that doesn't contain the empty cell to get the target
	var target int64 = -1
	for i := 0; i < n; i++ {
		if i != emptyRow {
			target = rowSums[i]
			break
		}
	}

	if target == -1 {
		// All rows contain the empty cell? Impossible for n>1, since only one empty cell
		// This shouldn't happen
		fmt.Fprintln(writer, -1)
		return
	}

	// x = target - rowSums[emptyRow]
	x := target - rowSums[emptyRow]

	if x <= 0 {
		fmt.Fprintln(writer, -1)
		return
	}

	// Verify: place x and check all conditions
	grid[emptyRow][emptyCol] = x

	// Recalculate all sums
	valid := true

	// Check all rows
	for i := 0; i < n; i++ {
		var sum int64
		for j := 0; j < n; j++ {
			sum += grid[i][j]
		}
		if sum != target {
			valid = false
			break
		}
	}

	if valid {
		// Check all cols
		for j := 0; j < n; j++ {
			var sum int64
			for i := 0; i < n; i++ {
				sum += grid[i][j]
			}
			if sum != target {
				valid = false
				break
			}
		}
	}

	if valid {
		// Check main diagonal
		var sum int64
		for i := 0; i < n; i++ {
			sum += grid[i][i]
		}
		if sum != target {
			valid = false
		}
	}

	if valid {
		// Check secondary diagonal
		var sum int64
		for i := 0; i < n; i++ {
			sum += grid[i][n-1-i]
		}
		if sum != target {
			valid = false
		}
	}

	if valid {
		fmt.Fprintln(writer, x)
	} else {
		fmt.Fprintln(writer, -1)
	}
}
```