package main

import "fmt"

var pos int

type Vertex struct {
	mark, pos, number, depth, parent *int
	next []int
	signals []string
}

func union(x, y int, delta []Vertex) {
	rootx := find(x, delta)
	rooty := find(y, delta)
	if *delta[rootx].depth < *delta[rooty].depth {
		*delta[rootx].parent = *delta[rooty].number
	} else {
		*delta[rooty].parent = rootx
		if *delta[rootx].depth == *delta[rooty].depth && rootx != rooty {
			*delta[rootx].depth++
		}
	}
}

func find(v int, delta []Vertex) int {
	if v == *delta[*delta[v].parent].number {
		return v
	}
	*delta[v].parent = find(*delta[v].parent, delta)
	return *delta[v].parent
}

func VV(pos int, Delta []int, delta []Vertex, res []Vertex, Len int) {
	is := false
	var i int
	for i = 0; i < Len; i++ {
		if pos == Delta[i] {
			is = true
			break
		}
	}
	if is {
		v := delta[i]
		*v.mark = 1
		*v.pos = pos
		res[pos] = v
		pos++
		for _, x := range v.next {
			u := delta[x]
			if *u.mark == 0 && *v.number != *u.number {
				VV(*u.number, Delta, delta, res, Len)
			}
		}
		*v.mark = 2
	}
}

func main() {
	var n, m, q0, i, j, k int
	pos = 0
	fmt.Scanf("%d\n%d\n%d\n", &n, &m, &q0)
	min := n
	delta := make([]Vertex, n)
	for i = 0; i < n; i++ {
		delta[i] = Vertex{new(int), new(int), new(int), new(int), new(int), make([]int, m), make([]string, m)}
		*delta[i].parent = i
		*delta[i].depth = 0
		*delta[i].mark = 0
		*delta[i].pos = 0
		*delta[i].number = i
		for j = 0; j < m; j++ {
			fmt.Scan(&delta[i].next[j])
		}
	}
	for i = 0; i < n; i++ {
		for j = 0; j < m; j++ {
			fmt.Scan(&delta[i].signals[j])
		}
	}
	//SPLIT1---------------------------------
	pi := make([]int, n)
	for i = 0; i < n; i++ {
		for j = i + 1; j < n; j++ {
			if find(i, delta) != find(j, delta) {
				eq := true
				for k = 0; k < m; k++ {
					if delta[i].signals[k] != delta[j].signals[k] {
						eq = false
						break
					}
				}
				if eq {
					union(i, j, delta)
					//fmt.Println(*delta[i].parent, *delta[j].parent)
					min--
				}
			}
		}
	}
	for i = 0; i < n; i++ {
		pi[i] = find(i, delta)
	}
	//---------------------------
	for {
		//SPLIT-----------------
		min = n
		for i = 0; i < n; i++ {
			*delta[i].parent = i
			*delta[i].depth = 0
		}
		for i = 0; i < n; i++ {
			for j = i + 1; j < n; j++ {
				a := find(i, delta)
				b := find(j, delta)
				if pi[i] == pi[j] && a != b {
					eq := true
					for k = 0; k < m; k++ {
						w1 := delta[i].next[k]
						w2 := delta[j].next[k]
						if pi[w1] != pi[w2] {
							eq = false
							break
						}
					}
					if eq {
						union(i, j, delta)
						min--
					}
				}
			}
		}
		for i = 0; i < n; i++ {
			pi[i] = find(i, delta)
			fmt.Println(pi)
		}
		//----------------------
		if min == n {
			break
		}
	}
	//--------------------------
	Len := 0
	Delta := make([]int, n)
	for i = 0; i < n; i++ {
		q := pi[i]
		is := true
		for j = 0; j < Len; j++ {
			if q == Delta[j] {
				is = false
				break
			}
		}
		if is {
			Delta[Len] = q
			Len++
		}
	}

	res := make([]Vertex, Len)
	VV(q0, Delta, delta, res, Len)

	fmt.Printf("digraph {\n\trankdir = LR\n\tdummy [label = \"\", shape = none]\n")
	for i = 0; i < Len; i++ {
		fmt.Printf("\t%d [shape = circle]\n", *res[i].number)
	}
	fmt.Printf("\tdummy -> %d\n", 0)
	for i = 0; i < Len; i++ {
		for j = 0; j < m; j++ {
			fmt.Printf("\t%d -> %d [label = \"%c(%s)\"]\n", i, res[i].next[j], 97 + j, res[i].signals[j])
		}
	}
	fmt.Printf("}\n")
}