import sys

def main():

    input = sys.stdin.readline

    N, M, K = list(map(int, input().split()))

    AB = [tuple(map(int, input().split())) for _ in range(M)]

    CD = [tuple(map(int, input().split())) for _ in range(K)]



    uf = UnionFindTree(N)

    friend_or_block = [set() for _ in range(N)]

    for a, b in AB:

        a, b = a-1, b-1

        uf.union(a, b)

        friend_or_block[a].add(b)

        friend_or_block[b].add(a)

    for c, d in CD:

        c, d = c-1, d-1

        if uf.same(c, d):

            friend_or_block[c].add(d)

            friend_or_block[d].add(c)

    

    print((*[uf.size(i) - len(friend_or_block[i]) - 1 for i in range(N)]))



class UnionFindTree:

    def __init__(self, n):

        self.parent = [-1] * n



    def find(self, x):

        p = self.parent

        while p[x] >= 0: x, p[x] = p[x], p[p[x]]

        return x



    def union(self, x, y):

        x, y, p = self.find(x), self.find(y), self.parent

        if x == y: return

        if p[x] > p[y]: x, y = y, x

        p[x], p[y] = p[x] + p[y], x



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

    def size(self, x): return -self.parent[self.find(x)]



if __name__ == '__main__':

    main()
# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)

from typing import Iterable

import sys

def main(N, M, K, AB, CD):

    friend_chain = UnionFindTree(N)

    friend_count = [0] * N

    block_count = [0] * N

    for a, b in AB:

        a, b = a - 1, b - 1

        friend_chain.union(a, b)

        friend_count[a] += 1

        friend_count[b] += 1

    for c, d in CD:

        c, d = c - 1, d - 1

        if friend_chain.same(c, d):

            block_count[c] += 1

            block_count[d] += 1

    print((*[friend_chain.size(i) - 1 - friend_count[i] - block_count[i] for i in range(N)]))



class UnionFindTree:

    def __init__(self, n: int) -> None:

        self.parent = [-1] * n



    def find(self, x: int) -> int:

        p = self.parent

        while p[x] >= 0: x, p[x] = p[x], p[p[x]]

        return x



    def union(self, x: int, y: int) -> bool:

        x, y, p = self.find(x), self.find(y), self.parent

        if x == y: return False

        if p[x] > p[y]: x, y = y, x

        p[x], p[y] = p[x] + p[y], x

        return True



    def same(self, x: int, y: int) -> bool:

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



    def size(self, x: int) -> int:

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



    def same_all(self, indices: Iterable[int]) -> bool:

        f, v = self.find, self.find(indices[0])

        return all(f(i) == v for i in indices)



if __name__ == '__main__':

    input = sys.stdin.readline

    N, M, K = list(map(int, input().split()))

    AB = [tuple(map(int, input().split())) for _ in range(M)]

    CD = [tuple(map(int, input().split())) for _ in range(K)]

    main(N, M, K, AB, CD)

import sys


def main():
    input = sys.stdin.readline
    N, M, K = list(map(int, input().split()))
    AB = [tuple(map(int, input().split())) for _ in range(M)]
    CD = [tuple(map(int, input().split())) for _ in range(K)]
    uf = UnionFindTree(N)
    friend_or_block = [set() for _ in range(N)]
    for a, b in AB:
        a, b = a - 1, b - 1
        uf.union(a, b)
        friend_or_block[a].add(b)
        friend_or_block[b].add(a)
    for c, d in CD:
        c, d = c - 1, d - 1
        if uf.same(c, d):
            friend_or_block[c].add(d)
            friend_or_block[d].add(c)
    print((*[uf.size(i) - len(friend_or_block[i]) - 1 for i in range(N)]))


class UnionFindTree:
    def __init__(self, n):
        self.parent = [-1] * n

    def find(self, x):
        p = self.parent
        while p[x] >= 0:
            x, p[x] = p[x], p[p[x]]
        return x

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

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

    def size(self, x):
        return -self.parent[self.find(x)]


if __name__ == "__main__":
    main()

# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..)
from typing import Iterable
import sys


def main(N, M, K, AB, CD):
    friend_chain = UnionFindTree(N)
    friend_count = [0] * N
    block_count = [0] * N
    for a, b in AB:
        a, b = a - 1, b - 1
        friend_chain.union(a, b)
        friend_count[a] += 1
        friend_count[b] += 1
    for c, d in CD:
        c, d = c - 1, d - 1
        if friend_chain.same(c, d):
            block_count[c] += 1
            block_count[d] += 1
    print(
        (
            *[
                friend_chain.size(i) - 1 - friend_count[i] - block_count[i]
                for i in range(N)
            ]
        )
    )


class UnionFindTree:
    def __init__(self, n: int) -> None:
        self.parent = [-1] * n

    def find(self, x: int) -> int:
        p = self.parent
        while p[x] >= 0:
            x, p[x] = p[x], p[p[x]]
        return x

    def union(self, x: int, y: int) -> bool:
        x, y, p = self.find(x), self.find(y), self.parent
        if x == y:
            return False
        if p[x] > p[y]:
            x, y = y, x
        p[x], p[y] = p[x] + p[y], x
        return True

    def same(self, x: int, y: int) -> bool:
        return self.find(x) == self.find(y)

    def size(self, x: int) -> int:
        return -self.parent[self.find(x)]

    def same_all(self, indices: Iterable[int]) -> bool:
        f, v = self.find, self.find(indices[0])
        return all(f(i) == v for i in indices)


if __name__ == "__main__":
    input = sys.stdin.readline
    N, M, K = list(map(int, input().split()))
    AB = [tuple(map(int, input().split())) for _ in range(M)]
    CD = [tuple(map(int, input().split())) for _ in range(K)]
    main(N, M, K, AB, CD)

+# でつoO(YOU PLAY WITH THE CARDS YOU'RE DEALT..) +from typing import Iterable -def main(): -    input = sys.stdin.readline -    N, M, K = list(map(int, input().split())) -    AB = [tuple(map(int, input().split())) for _ in range(M)] -    CD = [tuple(map(int, input().split())) for _ in range(K)] -    uf = UnionFindTree(N) -    friend_or_block = [set() for _ in range(N)] +def main(N, M, K, AB, CD): +    friend_chain = UnionFindTree(N) +    friend_count = [0] * N +    block_count = [0] * N -        uf.union(a, b) -        friend_or_block[a].add(b) -        friend_or_block[b].add(a) +        friend_chain.union(a, b) +        friend_count[a] += 1 +        friend_count[b] += 1 -        if uf.same(c, d): -            friend_or_block[c].add(d) -            friend_or_block[d].add(c) -    print((*[uf.size(i) - len(friend_or_block[i]) - 1 for i in range(N)])) +        if friend_chain.same(c, d): +            block_count[c] += 1 +            block_count[d] += 1 +    print( +        ( +            *[ +                friend_chain.size(i) - 1 - friend_count[i] - block_count[i] +                for i in range(N) +            ] +        ) +    ) -    def __init__(self, n): +    def __init__(self, n: int) -> None: -    def find(self, x): +    def find(self, x: int) -> int: -    def union(self, x, y): +    def union(self, x: int, y: int) -> bool: -            return +            return False +        return True -    def same(self, x, y): +    def same(self, x: int, y: int) -> bool: -    def size(self, x): +    def size(self, x: int) -> int: + +    def same_all(self, indices: Iterable[int]) -> bool: +        f, v = self.find, self.find(indices[0]) +        return all(f(i) == v for i in indices) -    main() +    input = sys.stdin.readline +    N, M, K = list(map(int, input().split())) +    AB = [tuple(map(int, input().split())) for _ in range(M)] +    CD = [tuple(map(int, input().split())) for _ in range(K)] +    main(N, M, K, AB, CD)