object Main extends App {
	val sc = new java.util.Scanner(System.in)
	val pw = new java.io.PrintWriter(System.out)
	
	@scala.annotation.tailrec
	def loop(start: Int, end: Int)(f: Int => Unit) {
		if (start <= end) {
			f(start)
			loop(start + 1, end)(f)
		}
	}
	
	val n, m, k = sc.nextInt
	
	val friend, blocked = Array.fill(n+1)(0)
	val uf = UnionFind(1 to n)
	
	Seq.fill(m)((sc.nextInt, sc.nextInt)) foreach { case (a, b) =>
		uf.unite(a, b)
		friend(a) = friend(a) + 1
		friend(b) = friend(b) + 1
	}
	
	Seq.fill(k)((sc.nextInt, sc.nextInt)) foreach { case (c, d) =>
		if (uf.same(c,d)) {
			blocked(c) = blocked(c) + 1
			blocked(d) = blocked(d) + 1
		}
	}
 
	loop(1, n) { i =>
		pw.print( (uf.size(i) - 1 - friend(i) - blocked(i)).toString + " " )
	}
	pw.flush()
}
 
case class UnionFind[T](seq: Seq[T]) {
	import scala.collection.mutable.Map
	private[this] val par: Map[T, T] = Map[T,T](seq.map(elem => elem -> elem): _*)
	private[this] val sz: Map[T, Int] = Map[T, Int](seq.map(elem => elem -> 1): _*)
 
	@scala.annotation.tailrec
	private[this] def find(t: T, acc: Seq[T] = Nil): T = {
		val p = par(t)
		if (p == t) {acc foreach { par(_) = t }; t} else find(p, p +: acc)
	}
 
	def unite(a: T, b: T): Unit = {
		val pa = find(a)
		val pb = find(b)
		
		if (pa == pb) return
		
		if (sz(pa) <= sz(pb)) {
			par(pa) = pb
			sz(pb)  = sz(pa) + sz(pb)
		} else {
			par(pb) = pa
			sz(pa)  = sz(pa) + sz(pb)
		} 
	}
 
	def same(a: T, b: T) = find(a) == find(b)
	
	def size(a: T) = sz(find(a))
}
