package main

import (
	"fmt"
)

func main() {
	var N, X, Y, Z int
	fmt.Scan(&N, &X, &Y, &Z)
	mg := magicSquare(N)
	//print(mg)
	X--
	Y--
	N--
	//	fmt.Println(mg)
	//	fmt.Println(N, X, Y)
	//	if mg[X][Y] == Z {
	//		print(mg)
	//	} else if mg[N-X][Y] == Z {
	//		print1(mg)
	//	} else if mg[X][N-Y] == Z {
	//		print2(mg)
	//	} else {
	//		print3(mg)
	//	}
	//fmt.Println("------------------")
	//	print(mg)
	//	fmt.Println("------------------")
	//	print1(mg)
	//	fmt.Println("------------------")
	//	print2(mg)
	//	fmt.Println("------------------")
	//	print3(mg)
	//fmt.Println("------------------")
	var Zi, Zj int
	for i := 0; i < N; i++ {
		for j := 0; j < N; j++ {
			if mg[i][j] == Z {
				Zi = i
				Zj = j
			}
		}
	}
	mg[Y], mg[Zi] = mg[Zi], mg[Y]
	for i := 0; i < N; i++ {
		mg[i][X], mg[i][Zj] = mg[i][Zj], mg[i][X]
	}
	print(mg)
}

func doubleSliceInt(y, x int) [][]int {
	ss := make([][]int, y)
	for i := range ss {
		ss[i] = make([]int, x)
	}
	return ss
}

func odd(N int, z [][]int) [][]int {
	y := 0
	x := N / 2
	for i := 0; i < N*N; i++ {
		z[y][x] = i + 1
		y2 := (y + N - 1) % N
		x2 := (x + 1) % N
		if z[y2][x2] != 0 {
			y2 = (y + 1) % N
			x2 = x
		}
		y = y2
		x = x2
	}
	return z
}

func printz(z [][]int, a, b int) {
	for i := range z {
		for j := range z[i] {
			if i+a < 0 {
				i = i + len(z) + a
			} else {
				i = i + a
			}
			if j+b < 0 {
				j = j + len(z) + b
			} else {
				j = j + b
			}
			fmt.Println(i, j, a, b)
			fmt.Print(z[i][j], " ")
		}
		fmt.Println("")
	}
}
func print(z [][]int) {
	for i := range z {
		for j := range z[i] {
			fmt.Print(z[i][j], " ")
		}
		fmt.Println("")
	}
}

func print1(z [][]int) {
	l := len(z) - 1
	for i := range z {
		for j := range z[i] {
			fmt.Print(z[l-i][j], " ")
		}
		fmt.Println("")
	}
}

func print2(z [][]int) {
	l := len(z) - 1
	for i := range z {
		for j := range z[i] {
			fmt.Print(z[i][l-j], " ")
		}
		fmt.Println("")
	}
}

func print3(z [][]int) {
	l := len(z) - 1
	for i := range z {
		for j := range z[i] {
			fmt.Print(z[l-i][l-j], " ")
		}
		fmt.Println("")
	}
}

func magicSquare(N int) [][]int {
	z := doubleSliceInt(N, N)
	if N%2 == 1 {
		z = odd(N, z)
	} else if N%4 == 0 {
		for i := 0; i < N; i++ {
			for j := 0; j < N; j++ {
				if i%4 == j%4 || i%4+j%4 == 3 {
					z[i][j] = N*i + j + 1
				} else {
					z[i][j] = N*N - (N*i + j)
				}
			}
		}
	} else {
		n := (N - 2) / 4
		seed := doubleSliceInt(2*n+1, 2*n+1)
		seed = odd(2*n+1, seed)
		LUX := doubleSliceInt(2*n+1+1, 2*n+1)
		for i := 0; i < 2*n+1; i++ {
			LUX[(2*n+1)/2+1][i] = 1
		}
		for i := (2*n+1)/2 + 2; i < (2*n+1)+1; i++ {
			for j := 0; j < (2*n + 1); j++ {
				LUX[i][j] = 2
			}
		}
		LUX[N/4][N/4] = 1
		LUX[1+N/4][N/4] = 0
		L := [2][2]int{{4, 1}, {2, 3}}
		U := [2][2]int{{1, 4}, {2, 3}}
		X := [2][2]int{{1, 4}, {3, 2}}
		LUXmat := [3][2][2]int{L, U, X}
		for x := 0; x < N/2; x++ {
			for y := 0; y < N/2; y++ {
				val := (seed[x][y] - 1) * 4
				idx := LUX[x][y]
				for a := 0; a < 2; a++ {
					for b := 0; b < 2; b++ {
						z[2*x+a][2*y+b] = LUXmat[idx][a][b] + val
					}
				}
			}
		}
	}
	return z
}