private fun readAtOnce(): List<String> = readLine()!!.split(" ")
private fun readInts(): List<Int> = readAtOnce().map(String::toInt)
private fun readLongs(): List<Long> = readAtOnce().map(String::toLong)
private fun zeroArray(size: Int): IntArray = IntArray(size) { 0 }
private fun Int.repeat(predicate: (Int) -> Unit) = repeat(this, predicate)

private class UnionFind(N: Int) {
    private val parent = Array(N) { -1 }
    private val rank = zeroArray(N)

    fun findRoot(x: Int): Int =
            if (parent[x] < 0) {
                x
            } else {
                parent[x] = findRoot(parent[x])
                parent[x]
            }

    fun unite(x: Int, y: Int) {
        val rootX = findRoot(x)
        val rootY = findRoot(y)
        if (rootX == rootY) return

        if (rank[rootX] < rank[rootY]) {
            parent[rootY] += parent[rootX]
            parent[rootX] = rootY
        } else {
            parent[rootX] += parent[rootY]
            parent[rootY] = rootX
            if (rank[rootX] == rank[rootY]) rank[rootX]++
        }
    }

    fun hasInSameGroup(x: Int, y: Int): Boolean = findRoot(x) == findRoot(y)

    fun groupSizeOf(belongs: Int) = -parent[findRoot(belongs)]
}

// heap
private val friends = zeroArray(100004)
private val blocking = Array(100004) { mutableListOf<Int>() }

fun main(args: Array<out String>) {
    val (N, M, K) = readInts()
    val unionFind = UnionFind(N + 1)
    M.repeat {
        val (A, B) = readInts()
        unionFind.unite(A, B)
        friends[A]++
        friends[B]++
    }
    K.repeat {
        val (C, D) = readInts()
        blocking[C].add(D)
        blocking[D].add(C)
    }

    (1..N)
            .map { n -> unionFind.groupSizeOf(n) - 1 - friends[n] - blocking[n].count { blocked -> unionFind.hasInSameGroup(blocked, n) } }
            .joinToString(separator = " ")
            .let(::println)
}