package main

import (
    "fmt"
)

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

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)
        }
    }
    AufenkampHohn(arr1, n, m, q)
    //DFS(arr1, n, m, q)
}


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

    fmt.Printf("digraph {\n")
    fmt.Printf("    rankdir = LR\n")
    fmt.Printf("    dummy [label = \"\", shape = none]\n")
    for i := 0; i < n; i++ {
        fmt.Printf("    %d ", i)
        fmt.Printf("[shape = circle]\n")
    }
    fmt.Printf("    dummy -> 0\n")
    //fmt.Printf("%d\n", q)
    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            fmt.Printf("    %d -> %d [label = \"%c(%s)\"]\n", i, arr1[i][j].newStates, 97+j, arr1[i][j].newInputAlph)
        }
    }
    fmt.Printf("}")
}
//
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, q)

}

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
}

type State struct {
    order  int
    depth  int
    parent *State
}

func newState(order int) *State {
    s := &State{order: order, depth: 0}
    s.parent = s
    return s
}

func find(v int, arr[] int) int {
    if arr[v] == v {
        return v
    }
    arr[v] = find(arr[v], arr)
    return arr[v]

}

func unite(x, y int, arr[] int)  {
    xx := find(x, arr)
    yy := find(y, arr)
    if xx == yy {
        return
    }
    if xx != yy {
        xx, yy = yy, xx
    }
    arr[xx] = yy
}

func Split1(arr1[][] Graph, n, m int) (int ,[]int) {
    var eq bool
    M := n
    pi := make([]int, n)
    for i := 0; i < n; i++ {
        pi[i] = i
    }
    for q1 := 0; q1 < n; q1++ {
        for q2 := q1+1; q2 < n; q2++{
            if find(q1, pi) != find(q2, pi){
                eq = true
                for x := 0; x < m; x++{
                    if arr1[q1][x].InputAlph != arr1[q2][x].InputAlph {
                        eq = false
                        break
                    }
                }
                if eq {
                    unite(q1, q2, pi)
                    M--
                }
            }
        }
    }
    for q := 0; q < n; q++ {
        pi[q] = find(q, pi)
    }
    return M, pi
}

func Split(arr1[][] Graph, pi[] int, n, m int) (int, []int) {
    var eq bool
    M := n
    newPi := make([]int, n)
    for i := 0; i < n; i++ {
        newPi[i] = i
    }
    for q1 := 0; q1 < n; q1++ {
        for q2 := q1 + 1; q2 < n; q2++ {
            if (pi[q1] == pi[q2]) && (find(q1, newPi) != find(q2, newPi)) {
                eq = true
                for x := 0; x < m; x++ {
                    w1 := arr1[q1][x].states
                    w2 := arr1[q2][x].states
                    if pi[w1] != pi[w2] {
                        eq = false
                        break
                    }
                }
                if eq {
                    unite(q1, q2, newPi)
                    M--
                }
            }
        }
    }
    for q := 0; q < n; q++ {
        pi[q] = find(q, newPi)
    }
    return M, pi
}

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

    M, pi := Split1(arr1, n, m)
    var (
        newM int
        //newPi[] int
        )
    for  {
        newM, pi = Split(arr1, pi, n, m)
        if M == newM {
            break
        }
        M = newM
    }
    /*count := 0
    for i := 0; i < n; i++ {
        if pi[i] < count {
            continue
        }
        pi[i] = count
        count++
    }*/
    arr := make([][] Graph, n, n)

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

    b := make([] bool, n)
    for q := 0; q < n; q++ {
        if newQ := pi[q]; !b[q] {
            b[newQ] = true
            for x := 0; x < m; x++ {
                arr[newQ][x].states = pi[arr1[q][x].states]
                arr[newQ][x].InputAlph = arr1[q][x].InputAlph
            }
        }
    }
    DFS(arr, M, m, pi[qq])
}