```go
package main

import (
	"fmt"
)

type Block struct {
	minR, maxR, minC, maxC int
	color                  byte
}

type State struct {
	block int
	dp    int
	cp    int
}

func main() {
	var m, n int
	if _, err := fmt.Scan(&m, &n); err != nil {
		return
	}
	grid := make([]string, m)
	for i := 0; i < m; i++ {
		fmt.Scan(&grid[i])
	}
	w := len(grid[0])

	blockID := make([][]int, m)
	for i := range blockID {
		blockID[i] = make([]int, w)
	}
	blocks := []Block{{}}

	id := 1
	for r := 0; r < m; r++ {
		for c := 0; c < w; c++ {
			if grid[r][c] != '0' && blockID[r][c] == 0 {
				maxC := c
				for maxC < w && grid[r][maxC] == grid[r][c] && blockID[r][maxC] == 0 {
					maxC++
				}
				maxC--

				maxR := r
				for maxR < m {
					allSame := true
					for cc := c; cc <= maxC; cc++ {
						if grid[maxR][cc] != grid[r][c] || blockID[maxR][cc] != 0 {
							allSame = false
							break
						}
					}
					if !allSame {
						break
					}
					maxR++
				}
				maxR--

				for rr := r; rr <= maxR; rr++ {
					for cc := c; cc <= maxC; cc++ {
						blockID[rr][cc] = id
					}
				}

				blocks = append(blocks, Block{
					minR: r, maxR: maxR, minC: c, maxC: maxC, color: grid[r][c],
				})
				id++
			}
		}
	}

	dr := []int{0, 1, 0, -1}
	dc := []int{1, 0, -1, 0}

	state := State{block: 1, dp: 0, cp: 0}
	seen := make(map[State]int)
	history := []State{state}

	for i := 0; i < n; i++ {
		if prevI, exists := seen[state]; exists {
			cycleLen := i - prevI
			rem := (n - i) % cycleLen
			state = history[prevI+rem]
			break
		}
		seen[state] = i

		b := blocks[state.block]
		var r, c int
		if state.dp == 0 {
			c = b.maxC
			if state.cp == 0 {
				r = b.minR
			} else {
				r = b.maxR
			}
		} else if state.dp == 1 {
			r = b.maxR
			if state.cp == 0 {
				c = b.maxC
			} else {
				c = b.minC
			}
		} else if state.dp == 2 {
			c = b.minC
			if state.cp == 0 {
				r = b.maxR
			} else {
				r = b.minR
			}
		} else if state.dp == 3 {
			r = b.minR
			if state.cp == 0 {
				c = b.minC
			} else {
				c = b.maxC
			}
		}

		nr, nc := r+dr[state.dp], c+dc[state.dp]
		var nextState State
		if nr >= 0 && nr < m && nc >= 0 && nc < w && grid[nr][nc] != '0' {
			nextState = State{block: blockID[nr][nc], dp: state.dp, cp: state.cp}
		} else {
			ncp := state.cp
			ndp := state.dp
			if state.cp == 0 {
				ncp = 1
			} else {
				ncp = 0
				ndp = (state.dp + 1) % 4
			}
			nextState = State{block: state.block, dp: ndp, cp: ncp}
		}

		history = append(history, nextState)
		state = nextState
	}

	fmt.Printf("%c\n", blocks[state.block].color)
}
```