```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type Pos struct{ r, c int }

var moves = []Pos{
	{1, 2}, {1, -2}, {-1, 2}, {-1, -2},
	{2, 1}, {2, -1}, {-2, 1}, {-2, -1},
}

func bfs(n, m, tr, tc int) [][]int {
	dist := make([][]int, n+1)
	for i := 0; i <= n; i++ {
		dist[i] = make([]int, m+1)
		for j := 0; j <= m; j++ {
			dist[i][j] = 1e9
		}
	}
	q := []Pos{{tr, tc}}
	dist[tr][tc] = 0
	head := 0
	for head < len(q) {
		curr := q[head]
		head++
		for _, mv := range moves {
			nr, nc := curr.r+mv.r, curr.c+mv.c
			if nr >= 1 && nr <= n && nc >= 1 && nc <= m {
				if dist[nr][nc] == 1e9 {
					dist[nr][nc] = dist[curr.r][curr.c] + 1
					q = append(q, Pos{nr, nc})
				}
			}
		}
	}
	return dist
}

func isKnightMove(r1, c1, r2, c2 int) bool {
	dr := r1 - r2
	if dr < 0 {
		dr = -dr
	}
	dc := c1 - c2
	if dc < 0 {
		dc = -dc
	}
	return (dr == 1 && dc == 2) || (dr == 2 && dc == 1)
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var allTokens []string

	for {
		line, err := reader.ReadString('\n')
		if err != nil && len(strings.TrimSpace(line)) == 0 {
			return
		}
		fields := strings.Fields(line)
		if len(fields) > 0 {
			if len(fields) == 1 {
			} else {
				allTokens = append(allTokens, fields...)
			}
			break
		}
	}

	nextToken := func() (string, bool) {
		if len(allTokens) > 0 {
			tok := allTokens[0]
			allTokens = allTokens[1:]
			return tok, true
		}
		for {
			line, err := reader.ReadString('\n')
			if err != nil && len(strings.TrimSpace(line)) == 0 {
				return "", false
			}
			parts := strings.Fields(line)
			if len(parts) > 0 {
				allTokens = append(allTokens, parts...)
				tok := allTokens[0]
				allTokens = allTokens[1:]
				return tok, true
			}
		}
	}

	readInt := func() (int, bool) {
		tok, ok := nextToken()
		if !ok {
			return 0, false
		}
		v, _ := strconv.Atoi(tok)
		return v, true
	}

	for {
		n, ok := readInt()
		if !ok {
			break
		}
		m, _ := readInt()
		x1, _ := readInt()
		y1, _ := readInt()
		x2, _ := readInt()
		y2, _ := readInt()

		tw_r, tw_c := n/2, m/2
		tb_r, tb_c := n/2+1, m/2

		distW := bfs(n, m, tw_r, tw_c)
		distB := bfs(n, m, tb_r, tb_c)

		dW := distW[x1][y1]
		dB := distB[x2][y2]

		pW := (x1 + y1) % 2
		pB := (x2 + y2) % 2

		var myColor string
		if pW != pB {
			if dW <= dB {
				myColor = "WHITE"
			} else {
				myColor = "BLACK"
			}
		} else {
			if dB <= dW-1 {
				myColor = "BLACK"
			} else {
				myColor = "WHITE"
			}
		}

		fmt.Println(myColor)

		var myR, myC, oppR, oppC int
		if myColor == "WHITE" {
			myR, myC = x1, y1
			oppR, oppC = x2, y2
		} else {
			myR, myC = x2, y2
			oppR, oppC = x1, y1
		}

		myTurn := (myColor == "WHITE")

		targetR, targetC := tw_r, tw_c
		myDist := distW
		if myColor == "BLACK" {
			targetR, targetC = tb_r, tb_c
			myDist = distB
		}

		for {
			if myR == oppR && myC == oppC {
				break
			}
			if myR == targetR && myC == targetC && !isKnightMove(myR, myC, oppR, oppC) {
				break
			}

			if myTurn {
				nextR, nextC := -1, -1
				if isKnightMove(myR, myC, oppR, oppC) {
					nextR, nextC = oppR, oppC
				} else {
					minD := 1000000000
					maxDistToOpp := -1

					for _, mv := range moves {
						nr, nc := myR+mv.r, myC+mv.c
						if nr >= 1 && nr <= n && nc >= 1 && nc <= m {
							if !isKnightMove(nr, nc, oppR, oppC) {
								d := myDist[nr][nc]
								distToOppSq := (nr-oppR)*(nr-oppR) + (nc-oppC)*(nc-oppC)
								if d < minD || (d == minD && distToOppSq > maxDistToOpp) {
									minD = d
									maxDistToOpp = distToOppSq
									nextR, nextC = nr, nc
								}
							}
						}
					}
					if nextR == -1 {
						for _, mv := range moves {
							nr, nc := myR+mv.r, myC+mv.c
							if nr >= 1 && nr <= n && nc >= 1 && nc <= m {
								nextR, nextC = nr, nc
								break
							}
						}
					}
				}

				fmt.Printf("%d %d\n", nextR, nextC)
				myR, myC = nextR, nextC

				if myR == oppR && myC == oppC {
					break
				}
				if myR == targetR && myC == targetC && !isKnightMove(myR, myC, oppR, oppC) {
					break
				}
			} else {
				r, ok := readInt()
				if !ok {
					return
				}
				c, _ := readInt()
				if r == -1 && c == -1 {
					return
				}
				oppR, oppC = r, c

				if oppR == myR && oppC == myC {
					break
				}
				oppTargetR, oppTargetC := tb_r, tb_c
				if myColor == "BLACK" {
					oppTargetR, oppTargetC = tw_r, tw_c
				}
				if oppR == oppTargetR && oppC == oppTargetC && !isKnightMove(oppR, oppC, myR, myC) {
					break
				}
			}
			myTurn = !myTurn
		}
	}
}
```