class UnionFind(n: Int) {
    private val parent = IntArray(n) { -1 }
    private val rank = IntArray(n)
    private val size = IntArray(n) { 1 }
    private var numTree = n

    fun find(x: Int): Int {
        if (parent[x] == -1) {
            return x
        } else {
            parent[x] = find(parent[x])
            return parent[x]
        }
    }

    fun isSame(x: Int, y: Int): Boolean {
        return find(x) == find(y)
    }

    fun getSize(): Int {
        return numTree
    }

    fun sizeOf(x: Int): Int {
        return size[find(x)]
    }

    fun rankOf(x: Int): Int {
        return rank[find(x)]
    }

    fun unite(x: Int, y: Int) {
        val parentX = find(x)
        val parentY = find(y)

        if (parentX == parentY) {
            return
        }

        numTree--

        if (rank[parentX] < rank[parentY]) {
            parent[parentX] = parentY
            size[parentY] += size[parentX]
        } else {
            parent[parentY] = parentX
            size[parentX] += size[parentY]
            if (rank[parentX] == rank[parentY]) {
                rank[parentX]++
            }
        }
    }
}

fun main() {
    val builder = StringBuilder()

    // 解説読む、問題が読解できなかった

    val (n, m, q) = readInputLine().split(" ").map { it.toInt() }

    val nodes = Array(n) { BooleanArray(7) }
    val edges = Array(n) { mutableListOf<Int>() }

    val uf = UnionFind(n * 7)

    for (i in 0 until n) {
        val s = readInputLine()
        for ((j, c) in s.withIndex()) {
            if (c == '1') {
                nodes[i][j] = true
            }
        }
        for (j in 0 until 7) {
            if (nodes[i][j] && nodes[i][(j + 1) % 7]) {
                uf.unite(i * 7 + j, i * 7 + (j + 1) % 7)
            }
        }
    }

    repeat(m) {
        val (u, v) = readInputLine().split(" ").map { it.toInt() - 1 }
        edges[u].add(v)
        edges[v].add(u)

        for (i in 0 until 7) {
            if (nodes[u][i] && nodes[v][i]) {
                uf.unite(u * 7 + i, v * 7 + i)
            }
        }
    }

    repeat(q) {
        val (type, x, y) = readInputLine().split(" ").map { it.toInt() - 1 }

        when(type) {
            0 -> {
                nodes[x][y] = true
                for (e in edges[x]) {
                    if (nodes[x][y] && nodes[e][y]) {
                        uf.unite(x * 7 + y, e * 7 + y)
                    }
                }
                for (i in 0 until 7) {
                    if (nodes[x][i] && nodes[x][(i + 1) % 7]) {
                        uf.unite(x * 7 + i, x * 7 + (i + 1) % 7)
                    }
                }
            }
            else -> {
                builder.appendln(uf.sizeOf(x * 7))
            }
        }
    }

    print(builder.toString())
}

fun readInputLine(): String {
    return readLine()!!
}