class UnionFind(n: Int) {
    val v = Array(n) {
        -1
    }

    fun unite(a: Int, b: Int) {
        val ar = find(a)
        val br = find(b)
        if (ar == br) {
            return
        }
        if (v[ar] > v[br]) {
            v[br] += v[ar]
            v[ar] = br
        } else {
            v[ar] += v[br]
            v[br] = ar
        }
    }

    fun find(i: Int): Int {
        if (v[i] < 0) {
            return i
        }
        v[i] = find(v[i])
        return v[i]
    }

    fun same(a: Int, b: Int): Boolean {
        return find(a) == find(b)
    }

    fun size(i: Int): Int {
        return -v[find(i)]
    }
}

fun main(args: Array<String>) {
    val (n, m, k) = readLine()?.split(" ")?.map(String::toInt) ?: return

    val friends = Array(n) { 0 }
    val blocks = hashMapOf<Int, MutableList<Int>>()
    val unionFind = UnionFind(n)

    repeat(m) {
        val (a, b) = readLine()?.split(" ")?.map { it.toInt() - 1 } ?: return
        friends[a]++
        friends[b]++
        unionFind.unite(a, b)
    }
    repeat(k) {
        val (a, b) = readLine()?.split(" ")?.map { it.toInt() - 1 } ?: return
        blocks[a]?.add(b) ?: run {
            blocks[a] = mutableListOf(b)
        }
        blocks[b]?.add(a) ?: run {
            blocks[b] = mutableListOf(a)
        }
    }
    val output = friends.mapIndexed { i, v ->
        unionFind.size(i) - v - 1 - (blocks[i]?.sumBy {
            if (unionFind.same(i, it)) {
                1
            } else {
                0
            }
        } ?: 0)
    }.joinToString(" ")
    println(output)
}
