import java.util.*

val MAX_N = 100000
val par = Array(MAX_N) {0}
val rank = Array(MAX_N) {0}
val size = Array(MAX_N) {0}

fun init() {
    for(i in 0 until MAX_N) {
        par[i] = i
        rank[i] = 0
        size[i] = 1
    }
}

fun find(a: Int): Int {
    if (par[a] == a){
        return a
    } else{
        par[a] = find(par[a])
        return par[a]
    }
}

fun unite(a:Int, b: Int) {
    val ta = find(a)
    val tb = find(b)
    if(ta == tb) return

    if(rank[ta] < rank[tb]){
        par[ta] = tb
        size[tb] += size[ta]
    }else{
        par[tb] = ta
        size[ta] += size[tb]
        if(rank[ta] == rank[tb]) rank[ta]++;
    }
}

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

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    val n = sc.nextInt()
    val m = sc.nextInt()
    val k = sc.nextInt()
    init()
    val countAB = Array(n) {0}
    repeat(m) {
        val a = sc.nextInt() - 1
        val b = sc.nextInt() - 1
        unite(a, b)
        countAB[a]++
        countAB[b]++
    }
    val countCD = Array(n) { mutableSetOf<Int>()}
    repeat(k) {
        val c = sc.nextInt() - 1
        val d = sc.nextInt() - 1
        countCD[c].add(d)
        countCD[d].add(c)
    }

    println((0 until n).map {
        val blockCount = countCD[it].count { pos -> same(it, pos) }
        (size[find(it)] - 1) - countAB[it] - blockCount
    }.joinToString(" "))
}