package main

import "fmt"

type Graph struct {
states int
InputAlph string
mark string
newStates int
newInputAlph string
}

type Vert struct {
        s    int
    mark string
}

func main() {

    var n, m, q int
    //ind := 0
    fmt.Scan(&n)
    fmt.Scan(&m)
    fmt.Scan(&q)

    arr1 := make([][] Graph, n, n)

    for i := 0; i < n; i++ {
        arr1[i] = make([] Graph, m)
    }

    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            fmt.Scan(&arr1[i][j].states)
            //arr1[i][j].mark = "white"
        }
    }

    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            fmt.Scan(&arr1[i][j].InputAlph)
        }
    }
    DFS(arr1, n, m, q)
}

func print(arr1[][] Graph, n, m int) {

    fmt.Println(n)
    fmt.Println(m)
    fmt.Println(0)

    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            fmt.Print(arr1[i][j].newStates)
            fmt.Print(" ")
        }
        fmt.Println()
    }

    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            fmt.Print(arr1[i][j].newInputAlph + " ")
        }
        fmt.Println()
    }
}

func NewMatrix(arr1[][] Graph, arr[] Vert, newN, n, m, q int)  {
    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            arr1[arr[i].s][j].newStates = arr[arr1[i][j].states].s
            arr1[arr[i].s][j].newInputAlph = arr1[i][j].InputAlph
        }
    }
    print(arr1, newN, m)

}

func DFS(arr1[][] Graph, n, m, q int) {
    stack := newStack(n)
    sizeStack := 0
    arr := make([] Vert, n)
    count := 0
    stack[sizeStack] = q
    sizeStack++
    for sizeStack > 0 {
        sizeStack--
        v := stack[sizeStack]
        if arr[v].mark != "black" {
            arr[v].mark = "black"
            arr[v].s = count
            count++
        }
        for i := m - 1; i > -1; i-- {
            u := arr1[v][i].states
            if arr[u].mark != "black" {
                stack[sizeStack] = u
                sizeStack++
            }
        }
    }
    NewMatrix(arr1, arr, count, n, m, q)
}

func newStack(n int) []int  {
    stack := make([]int, n*n)
    return stack
}