import sys, re

from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2

from collections import deque, defaultdict, Counter

from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby

from operator import itemgetter, mul

from copy import deepcopy

from string import ascii_lowercase, ascii_uppercase, digits

from bisect import bisect, bisect_left

from fractions import gcd

from heapq import heappush, heappop, heapify

from functools import reduce

def input(): return sys.stdin.readline().strip()

def INT(): return int(input())

def MAP(): return map(int, input().split())

def LIST(): return list(map(int, input().split()))

def ZIP(n): return zip(*(MAP() for _ in range(n)))

sys.setrecursionlimit(10 ** 9)

INF = float('inf')

mod = 10 ** 9 + 7



class UnionFind():

    def __init__(self, n):

        self.n = n

        # parents[i]: 要素iの親要素の番号

        # 要素iが根の場合、parents[i] = -(そのグループの要素数)

        self.parents = [-1] * n

    def find(self, x):

        if 0 > self.parents[x]:

            return x

        else:

            self.parents[x] = self.find(self.parents[x])

            return self.parents[x]

    def union(self, x, y):

        x = self.find(x)

        y = self.find(y)

        if x == y:

            return

        if self.parents[x] > self.parents[y]:

            x, y = y, x

        self.parents[x] += self.parents[y]

        self.parents[y] = x

    # 要素xが属するグループの要素数を返す

    def size(self, x):

        return -self.parents[self.find(x)]

    def same(self, x, y):

        return self.find(x) == self.find(y)

    # 要素xが属するグループに属する要素をリストで返す

    def members(self, x):

        root = self.find(x)

        return [i for i in range(self.n) if self.find(i) == root]

    # 全ての根の要素をリストで返す

    def roots(self):

        return [i for i, x in enumerate(self.parents) if 0 > x]

    # グループの数を返す

    def group_count(self):

        return len(self.roots())

    # 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す

    def all_group_members(self):

        return {r: self.members(r) for r in self.roots()}

    # print()での表示用

    # all_group_members()をprintする

    def __str__(self):

        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())





N, M, K = MAP()

friends = defaultdict(list)

tree = UnionFind(N)

for _ in range(M):

	A, B = MAP()

	tree.union(A-1, B-1)

	friends[A-1].append(B-1)

	friends[B-1].append(A-1)



blocks = defaultdict(list)

for _ in range(K):

	C, D = MAP()

	blocks[C-1].append(D-1)

	blocks[D-1].append(C-1)



for i in range(N):

	minus = 0

	for b in blocks[i]:

		if tree.same(i, b):

			minus += 1

	print(tree.size(i)-len(friends[i])-1-minus, end = " ")

print()



"""

print("friends")

print(friends)



print("blocks")

print(blocks)



i = 1

print("i={}".format(i))

print("tree.size(i)={}".format(tree.size(i)))

print("tree.find(i))={}".format(tree.find(i)))

print("tree.members(i)={}".format(tree.members(i)))

print("tree.roots={}".format(tree.roots()))

print("tree.group_count={}".format(tree.group_count()))

print("tree.all_group_members={}".format(tree.all_group_members()))

"""



import sys, re

from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees#, log2

from collections import deque, defaultdict, Counter

from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby

from operator import itemgetter, mul

from copy import deepcopy

from string import ascii_lowercase, ascii_uppercase, digits

from bisect import bisect, bisect_left

from fractions import gcd

from heapq import heappush, heappop, heapify

from functools import reduce

def input(): return sys.stdin.readline().strip()

def INT(): return int(input())

def MAP(): return map(int, input().split())

def LIST(): return list(map(int, input().split()))

def ZIP(n): return zip(*(MAP() for _ in range(n)))

sys.setrecursionlimit(10 ** 9)

INF = float('inf')

mod = 10 ** 9 + 7



class UnionFind():

    def __init__(self, n):

        self.n = n

        # parents[i]: 要素iの親要素の番号

        # 要素iが根の場合、parents[i] = -(そのグループの要素数)

        self.parents = [-1] * n

    def find(self, x):

        if 0 > self.parents[x]:

            return x

        else:

            self.parents[x] = self.find(self.parents[x])

            return self.parents[x]

    def union(self, x, y):

        x = self.find(x)

        y = self.find(y)

        if x == y:

            return

        if self.parents[x] > self.parents[y]:

            x, y = y, x

        self.parents[x] += self.parents[y]

        self.parents[y] = x

    # 要素xが属するグループの要素数を返す

    def size(self, x):

        return -self.parents[self.find(x)]

    def same(self, x, y):

        return self.find(x) == self.find(y)

    # 要素xが属するグループに属する要素をリストで返す

    def members(self, x):

        root = self.find(x)

        return [i for i in range(self.n) if self.find(i) == root]

    # 全ての根の要素をリストで返す

    def roots(self):

        return [i for i, x in enumerate(self.parents) if 0 > x]

    # グループの数を返す

    def group_count(self):

        return len(self.roots())

    # 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す

    def all_group_members(self):

        return {r: self.members(r) for r in self.roots()}

    # print()での表示用

    # all_group_members()をprintする

    def __str__(self):

        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())



N, M, K = MAP()



tree = UnionFind(N)

friends = [[] for _ in range(N)]



for _ in range(M):

	A, B = MAP()

	tree.union(A-1, B-1)

	friends[A-1].append(B-1)

	friends[B-1].append(A-1)



blocks = [[] for _ in range(N)]



for _ in range(K):

	C, D = MAP()

	blocks[C-1].append(D-1)

	blocks[D-1].append(C-1)



for i in range(N):

	ans = tree.size(i) - 1 - len(friends[i])

	blocks_cnt = 0

	for j in  blocks[i]:

		if tree.same(i, j):

			blocks_cnt += 1

	ans -= blocks_cnt

	print(ans, end=" ")

print()

import sys, re
from math import (
    ceil,
    sqrt,
    hypot,
    factorial,
    pi,
    sin,
    cos,
    tan,
    asin,
    acos,
    atan,
    radians,
    degrees,
)  # , log2
from collections import deque, defaultdict, Counter
from itertools import (
    accumulate,
    permutations,
    combinations,
    combinations_with_replacement,
    product,
    groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce


def input():
    return sys.stdin.readline().strip()


def INT():
    return int(input())


def MAP():
    return map(int, input().split())


def LIST():
    return list(map(int, input().split()))


def ZIP(n):
    return zip(*(MAP() for _ in range(n)))


sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7


class UnionFind:
    def __init__(self, n):
        self.n = n
        # parents[i]: 要素iの親要素の番号
        # 要素iが根の場合、parents[i] = -(そのグループの要素数)
        self.parents = [-1] * n

    def find(self, x):
        if 0 > self.parents[x]:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    # 要素xが属するグループの要素数を返す
    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    # 要素xが属するグループに属する要素をリストで返す
    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    # 全ての根の要素をリストで返す
    def roots(self):
        return [i for i, x in enumerate(self.parents) if 0 > x]

    # グループの数を返す
    def group_count(self):
        return len(self.roots())

    # 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す
    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    # print()での表示用
    # all_group_members()をprintする
    def __str__(self):
        return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())


N, M, K = MAP()
friends = defaultdict(list)
tree = UnionFind(N)
for _ in range(M):
    A, B = MAP()
    tree.union(A - 1, B - 1)
    friends[A - 1].append(B - 1)
    friends[B - 1].append(A - 1)
blocks = defaultdict(list)
for _ in range(K):
    C, D = MAP()
    blocks[C - 1].append(D - 1)
    blocks[D - 1].append(C - 1)
for i in range(N):
    minus = 0
    for b in blocks[i]:
        if tree.same(i, b):
            minus += 1
    print(tree.size(i) - len(friends[i]) - 1 - minus, end=" ")
print()
"""
print("friends")
print(friends)
print("blocks")
print(blocks)
i = 1
print("i={}".format(i))
print("tree.size(i)={}".format(tree.size(i)))
print("tree.find(i))={}".format(tree.find(i)))
print("tree.members(i)={}".format(tree.members(i)))
print("tree.roots={}".format(tree.roots()))
print("tree.group_count={}".format(tree.group_count()))
print("tree.all_group_members={}".format(tree.all_group_members()))
"""

import sys, re
from math import (
    ceil,
    sqrt,
    hypot,
    factorial,
    pi,
    sin,
    cos,
    tan,
    asin,
    acos,
    atan,
    radians,
    degrees,
)  # , log2
from collections import deque, defaultdict, Counter
from itertools import (
    accumulate,
    permutations,
    combinations,
    combinations_with_replacement,
    product,
    groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop, heapify
from functools import reduce


def input():
    return sys.stdin.readline().strip()


def INT():
    return int(input())


def MAP():
    return map(int, input().split())


def LIST():
    return list(map(int, input().split()))


def ZIP(n):
    return zip(*(MAP() for _ in range(n)))


sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7


class UnionFind:
    def __init__(self, n):
        self.n = n
        # parents[i]: 要素iの親要素の番号
        # 要素iが根の場合、parents[i] = -(そのグループの要素数)
        self.parents = [-1] * n

    def find(self, x):
        if 0 > self.parents[x]:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x

    # 要素xが属するグループの要素数を返す
    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    # 要素xが属するグループに属する要素をリストで返す
    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    # 全ての根の要素をリストで返す
    def roots(self):
        return [i for i, x in enumerate(self.parents) if 0 > x]

    # グループの数を返す
    def group_count(self):
        return len(self.roots())

    # 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す
    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

    # print()での表示用
    # all_group_members()をprintする
    def __str__(self):
        return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())


N, M, K = MAP()
tree = UnionFind(N)
friends = [[] for _ in range(N)]
for _ in range(M):
    A, B = MAP()
    tree.union(A - 1, B - 1)
    friends[A - 1].append(B - 1)
    friends[B - 1].append(A - 1)
blocks = [[] for _ in range(N)]
for _ in range(K):
    C, D = MAP()
    blocks[C - 1].append(D - 1)
    blocks[D - 1].append(C - 1)
for i in range(N):
    ans = tree.size(i) - 1 - len(friends[i])
    blocks_cnt = 0
    for j in blocks[i]:
        if tree.same(i, j):
            blocks_cnt += 1
    ans -= blocks_cnt
    print(ans, end=" ")
print()

-friends = defaultdict(list) +friends = [[] for _ in range(N)] -blocks = defaultdict(list) +blocks = [[] for _ in range(N)] -    minus = 0 -    for b in blocks[i]: -        if tree.same(i, b): -            minus += 1 -    print(tree.size(i) - len(friends[i]) - 1 - minus, end=" ") +    ans = tree.size(i) - 1 - len(friends[i]) +    blocks_cnt = 0 +    for j in blocks[i]: +        if tree.same(i, j): +            blocks_cnt += 1 +    ans -= blocks_cnt +    print(ans, end=" ") -""" -print("friends") -print(friends) -print("blocks") -print(blocks) -i = 1 -print("i={}".format(i)) -print("tree.size(i)={}".format(tree.size(i))) -print("tree.find(i))={}".format(tree.find(i))) -print("tree.members(i)={}".format(tree.members(i))) -print("tree.roots={}".format(tree.roots())) -print("tree.group_count={}".format(tree.group_count())) -print("tree.all_group_members={}".format(tree.all_group_members())) -"""