fun main(args: Array<String>) {
    val (N, M, K) = listOfInt()
    val U = UnionFind(N)
    val D = IntArray(N)
    val G = Array(N) { mutableListOf<Int>() }
    repeat(M) {
        val (a, b) = listOfInt(-1)
        D[a] += 1; D[b] += 1
        U.union(a, b)
    }
    repeat(K) {
        val (c, d) = listOfInt(-1)
        G[c].add(d); G[d].add(c)
    }
    val ans = IntArray(N)
    repeat(N) { n ->
        var f = U.size(n) - 1 - D[n]
        for (u in G[n]) {
            if (U.same(n, u)) f -= 1
        }
        ans[n] = f
    }
    println(ans.joinToString(separator = " "))
}
fun next() = readLine()!!
fun listOfString() = next().split(" ")
fun listOfInt(delta: Int = 0) = listOfString().map { Integer.parseInt(it) + delta }
class UnionFind(n: Int) {
    var rank: IntArray
    var par:  IntArray
    var size: IntArray
    init {
        this.rank = IntArray(n) { 0 }
        this.par  = IntArray(n) { it }
        this.size = IntArray(n) { 1 }
    }
    fun union(x: Int, y: Int): Boolean {
        var rx = this.root(x)
        var ry = this.root(y)
        if (rx == ry) return false
        if (this.rank[rx] < this.rank[ry]) {
            val w = rx
            rx = ry
            ry = w
        } else if (this.rank[rx] == this.rank[ry]) {
            this.rank[rx] += 1
        }
        this.par[ry] = rx
        this.size[rx] += this.size[ry]
        return true
    }
    fun find(x: Int): Int {
        if (this.par[x] == x) return x
        else {
            this.par[x] = this.find(this.par[x])
            return this.par[x]
        }
    }
    fun same(x: Int, y: Int) = this.root(x) == this.root(y)
    fun size(x: Int): Int = this.size[this.find(x)]
    fun root(x: Int): Int = this.find(x)
    fun unite(x: Int, y: Int) = this.union(x, y)
}
