package main

import (
    "fmt"
)

func main() {
    var n, m, q, index int

    fmt.Scan(&n, &m, &q)

    var (
        intArray       = make([][]int, n)
        stringArray    = make([][]string, n)
        stringNewArray = make([][]string, n)
        intNewArray    = make([][]int, n)
    )

    for i := 0; i < n; i++ {
        intNewArray[i] = make([]int, m)
        stringNewArray[i] = make([]string, m)
        intArray[i] = make([]int, m)
        stringArray[i] = make([]string, m)
    }

    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            fmt.Scan(&intArray[i][j])
        }
    }

    for i := 0; i < n; i++ {
        for j := 0; j < m; j++ {
            fmt.Scan(&stringArray[i][j])
        }
    }

}

func DFS(check [] int, array [][] int, begin int, index *int, m int) {
    check[begin] = *index
    *index++
    for i := 0; i < m; i++ {
        if (check[array[begin][i]] == -1) {
            DFS(check, array, array[begin][i], index, m);
        }
    }
}

func Canon(stringarrayold [][] string, intarrrayold [][] int, stringarraynew [][] string, intarrraynew [][] int, array [][] int, m int, n int, q int) {
    var check = make([]int, n)
    for i := 0; i < n; i++ {
        check[i] = -1
    }
    var index = 0
    DFS(check, array, q, &index, m)
    for i := 0; i < n; i++ {
        if (check[i] != -1) {
            stringarraynew[check[i]] = stringarrayold[i]
            for j := 0; j < m; j++ {
                intarrraynew[check[i]][j] = check[intarrrayold[i][j]]
            }
        }
        q = 0
        n = index
        intarrrayold = intarrraynew
        stringarrayold = stringarraynew
    }
}

func find(array [] int, z int) (x int) {
    if (array[z] == z) {
        x = z
        return
    } else {
        array[z] = find(array, array[z])
        x = array[z]
        return
    }
}

func Union(array [] int, x int, y int) {
    var (
        x_new = find(array, x)
        y_new = find(array, y)
    )
    if x_new == y_new {
        return
    }
    array[x_new] = y_new;
}

func Split(array [] int, m int, n int, intarray [][] int) {
    m = n;
    var superarray = make([]int, n)
    for i := 0; i < m; i++ {
        superarray[i] = i
    }
    for i := 0; i < n; i++ {
        for j := i + 1; j < n; j++ {
            if array[i] == array[j] && find(superarray, i) != find(superarray, j) {
                var eq bool = true
                for k := 0; k < m; k++ {
                    if (array[intarray[i][k]] != array[intarray[j][k]]) {
                        eq = false
                        break
                    }
                }
                if (eq) {
                    Union(superarray, i, j)
                    m--
                }
            }
        }
    }
    for i := 0; i < n; i++ {
        array[i] = find(superarray, i)
        }
    }


func Split1(n int, m int, stringarray[][] string, array [] int) {
    var (
        q int
        eq bool
    )
    q = n
    var superarray = make([]int, n)
    for i := 0; i < m; i++ {
        superarray[i] = i
    }
    for i := 0; i < n; i++ {
        for j := i + 1; j < n; j++ {
            if find(superarray, i) != find(superarray, j) {
                eq = true
                for k := 0; k < m; k++ {
                    if (stringarray[i][k] != stringarray[j][k]) {
                        eq = false
                        break
                    }
                }
                if (eq) {
                    Union(superarray, i, j);
                    q--
                }
            }
        }
    }
    for i := 0; i < n; i++ {
        array[i] = find(superarray, i)
    }
}


func AufenkampHohn() {
    vector<int> help(n);
int m1, m2 = -1;
Split1(m1, help);
while(m1 != m2) {
m2 = m1;
Split(m1, help);
}
vector<int> help1(n), help2(n);
for(int i = 0, a = 0; i < n; i++)
if (help[i] == i) {
help2[a] = i;
help1[i] = a++;
}
this->n = m1;
this->q = help1[help[this->q]];
vector<vector<string>> p(this->n, vector<string>(this->m));
for(int i = 0; i < n; i++)
for(int j = 0; j < m; j++) {
one[i][j] = help1[help[one[help2[i]][j]]];
p[i][j] = two[help2[i]][j];
}
two = p;
}