class UnionFind:
    def __init__(self, N):
        self.N = N

        # the parent of all node is itself
        # self.parent = list(range(N))
        self.parent = [-1] * N

    def root(self, i):
        if self.parent[i] < 0:
            return i

        r = self.root(self.parent[i])
        self.parent[i] = r
        return r

    def unite(self, i, j):
        i = self.root(i)
        j = self.root(j)

        if i == j:
            return

        if i > j:
            i, j = j, i

        self.parent[i] += self.parent[j]
        self.parent[j] = i
        # print(self.parent)

    def same(self, i, j):
        return self.root(i) == self.root(j)

    def size(self, i):
        return -self.parent[self.root(i)]

    def roots(self):
        return [self.root(i) for i in range(self.N)]

    def groupcount(self):
        return len(set(self.roots()))

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

notfriend = [set() for _ in range(N)]
forest = UnionFind(N)

# friend
for i in range(M):
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    notfriend[a].add(b)
    notfriend[b].add(a)

    forest.unite(a, b)

# block
for i in range(K):
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    if forest.same(a, b):
        notfriend[a].add(b)
        notfriend[b].add(a)

ans = ' '.join([str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N)])
print(ans) class UnionFind:
    def __init__(self, N):
        self.N = N

        # the parent of all node is itself
        # self.parent = list(range(N))
        self.parent = [-1] * N

    def root(self, i):
        if self.parent[i] < 0:
            return i

        r = self.root(self.parent[i])
        self.parent[i] = r
        return r

    def unite(self, i, j):
        i = self.root(i)
        j = self.root(j)

        if i == j:
            return

        if i > j:
            i, j = j, i

        self.parent[i] += self.parent[j]
        self.parent[j] = i
        # print(self.parent)

    def same(self, i, j):
        return self.root(i) == self.root(j)

    def size(self, i):
        return -self.parent[self.root(i)]

    def roots(self):
        return [self.root(i) for i in range(self.N)]

    def groupcount(self):
        return len(set(self.roots())) UnionFind def __init__(self, N):
        self.N = N

        # the parent of all node is itself
        # self.parent = list(range(N))
        self.parent = [-1] * N

     __init__ self.N = N self.N self N N self.parent = [-1] * N self.parent self parent [-1] * N [-1] -1 N self self N N def root(self, i):
        if self.parent[i] < 0:
            return i

        r = self.root(self.parent[i])
        self.parent[i] = r
        return r

     root if self.parent[i] < 0:
            return i

         self.parent[i] < 0 self.parent[i] self.parent self parent i 0 return i i r = self.root(self.parent[i]) r self.root(self.parent[i]) self.root self root self.parent[i] self.parent self parent i self.parent[i] = r self.parent[i] self.parent self parent i r return r r self self i i def unite(self, i, j):
        i = self.root(i)
        j = self.root(j)

        if i == j:
            return

        if i > j:
            i, j = j, i

        self.parent[i] += self.parent[j]
        self.parent[j] = i
        # print(self.parent)

     unite i = self.root(i) i self.root(i) self.root self root i j = self.root(j) j self.root(j) self.root self root j if i == j:
            return

         i == j i j return if i > j:
            i, j = j, i

         i > j i j i, j = j, i i j j i self.parent[i] += self.parent[j] self.parent[i] self.parent self parent i self.parent[j] self.parent self parent j self.parent[j] = i self.parent[j] self.parent self parent j i self self i i j j def same(self, i, j):
        return self.root(i) == self.root(j)

     same return self.root(i) == self.root(j) self.root(i) == self.root(j) self.root(i) self.root self root i self.root(j) self.root self root j self self i i j j def size(self, i):
        return -self.parent[self.root(i)]

     size return -self.parent[self.root(i)] -self.parent[self.root(i)] self.parent[self.root(i)] self.parent self parent self.root(i) self.root self root i self self i i def roots(self):
        return [self.root(i) for i in range(self.N)]

     roots self.root(i) for i in range(self.N) for i in range(self.N) i range(self.N) range self.N self N for i in range(self.N) self.root(i) self.root self root i return [self.root(i) for i in range(self.N)] [self.root(i) for i in range(self.N)] self self def groupcount(self):
        return len(set(self.roots())) groupcount return len(set(self.roots())) len(set(self.roots())) len set(self.roots()) set self.roots() self.roots self roots self self N, M, K = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M K set() for _ in range(N) for _ in range(N) _ range(N) range N for _ in range(N) set() set notfriend = [set() for _ in range(N)] notfriend [set() for _ in range(N)] forest = UnionFind(N) forest UnionFind(N) UnionFind N for i in range(M):
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    notfriend[a].add(b)
    notfriend[b].add(a)

    forest.unite(a, b)

# block i range(M) range M a, b = map(int, input().split()) a map(int, input().split()) map int input().split() ().split () input split b a, b = a - 1, b - 1 a a - 1 a 1 b b - 1 b 1 notfriend[a].add(b) [a].add [a] notfriend a add b notfriend[b].add(a) [b].add [b] notfriend b add a forest.unite(a, b) forest.unite forest unite a b for i in range(K):
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    if forest.same(a, b):
        notfriend[a].add(b)
        notfriend[b].add(a) i range(K) range K a, b = map(int, input().split()) a map(int, input().split()) map int input().split() ().split () input split b a, b = a - 1, b - 1 a a - 1 a 1 b b - 1 b 1 if forest.same(a, b):
        notfriend[a].add(b)
        notfriend[b].add(a) forest.same(a, b) forest.same forest same a b notfriend[a].add(b) [a].add [a] notfriend a add b notfriend[b].add(a) [b].add [b] notfriend b add a str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N) for i in range(N) i range(N) range N for i in range(N) str(forest.size(i) - 1 - len(notfriend[i])) str forest.size(i) - 1 - len(notfriend[i]) forest.size(i) - 1 forest.size(i) forest.size forest size i 1 len(notfriend[i]) len notfriend[i] notfriend i ans = ' '.join([str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N)]) ans ' '.join([str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N)]) ' '.join ' ' join [str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N)] print(ans) print ans a, b = map(int, input().split()) map(int, input().split()) a ans = ' '.join([str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N)]) ' '.join([str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N)]) ans class UnionFind:
    def __init__(self, N):
        self.N = N

        # the parent of all node is itself
        # self.parent = list(range(N))
        self.parent = [-1] * N

    def root(self, i):
        if self.parent[i] < 0:
            return i

        r = self.root(self.parent[i])
        self.parent[i] = r
        return r

    def unite(self, i, j):
        i = self.root(i)
        j = self.root(j)

        if i == j:
            return

        if i > j:
            i, j = j, i

        self.parent[i] += self.parent[j]
        self.parent[j] = i
        # print(self.parent)

    def same(self, i, j):
        return self.root(i) == self.root(j)

    def size(self, i):
        return -self.parent[self.root(i)]

    def roots(self):
        return [self.root(i) for i in range(self.N)]

    def groupcount(self):
        return len(set(self.roots())) class UnionFind:
    def __init__(self, N):
        self.N = N

        # the parent of all node is itself
        # self.parent = list(range(N))
        self.parent = [-1] * N

    def root(self, i):
        if self.parent[i] < 0:
            return i

        r = self.root(self.parent[i])
        self.parent[i] = r
        return r

    def unite(self, i, j):
        i = self.root(i)
        j = self.root(j)

        if i == j:
            return

        if i > j:
            i, j = j, i

        self.parent[i] += self.parent[j]
        self.parent[j] = i
        # print(self.parent)

    def same(self, i, j):
        return self.root(i) == self.root(j)

    def size(self, i):
        return -self.parent[self.root(i)]

    def roots(self):
        return [self.root(i) for i in range(self.N)]

    def groupcount(self):
        return len(set(self.roots())) UnionFind a, b = a - 1, b - 1 a - 1 a N, M, K = map(int, input().split()) map(int, input().split()) N a, b = a - 1, b - 1 a - 1 a M, K = map(int, input().split()) map(int, input().split()) M forest = UnionFind(N) UnionFind(N) forest a, b = map(int, input().split()) map(int, input().split()) a b = a - 1, b - 1 b - 1 b b = a - 1, b - 1 b - 1 b K = map(int, input().split()) map(int, input().split()) K notfriend = [set() for _ in range(N)] [set() for _ in range(N)] notfriend b = map(int, input().split()) map(int, input().split()) b b = map(int, input().split()) map(int, input().split()) b
class UnionFind:
    def __init__(self, N):
        self.N = N

        # the parent of all node is itself
        # self.parent = list(range(N))
        self.parent = [-1] * N

    def root(self, i):
        if self.parent[i] < 0:
            return i

        r = self.root(self.parent[i])
        self.parent[i] = r
        return r

    def unite(self, i, j):
        i = self.root(i)
        j = self.root(j)

        if i == j:
            return

        if i > j:
            i, j = j, i

        self.parent[i] += self.parent[j]
        self.parent[j] = i
        # print(self.parent)

    def same(self, i, j):
        return self.root(i) == self.root(j)

    def size(self, i):
        return -self.parent[self.root(i)]

    def roots(self):
        return [self.root(i) for i in range(self.N)]

    def groupcount(self):
        return len(set(self.roots()))

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

notfriend = [set() for _ in range(N)]
forest = UnionFind(N)

# friend
for i in range(M):
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    notfriend[a].add(b)
    notfriend[b].add(a)

    forest.unite(a, b)

# block
for i in range(K):
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    if forest.same(a, b):
        notfriend[a].add(b)
        notfriend[b].add(a)

ans = ' '.join([str(forest.size(i) - 1 - len(notfriend[i])) for i in range(N)])
print(ans)