package main

import (
	"fmt"
)

func main() {
	var N, X, Y, Z int
	fmt.Scan(&N, &X, &Y, &Z)
	mg := magicSquare(N)
	X--
	Y--
	//N--
	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)
	b := Zi - Y
	a := Zj - X
	print2(mg, a, b)
}

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

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 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
}