class UnionFind:



    def __init__(self, n):

        # parent[x] < 0 means x is root and abs(parent[x]) == size[x]

        self.parent, self.depth = [-1] * n, [0] * n



    def find(self, x):

        if self.parent[x] < 0:

            return x

        else:

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

            return self.parent[x]



    def isSame(self, x, y):

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



    def unite(self, x, y):

        if self.isSame(x, y):

            return

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



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

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

            self.parent[y] = x

        else:

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

            self.parent[x] = y

            if self.depth[x] == self.depth[y]:

                self.depth[y] += 1



    def size(self, x):

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





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

Friend, Block = {i: [] for i in range(N)}, {i: [] for i in range(N)}

union = UnionFind(N)

for _ in range(M):

    A, B = list(map(int, input().split()))

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

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

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

for _ in range(K):

    C, D = list(map(int, input().split()))

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

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



ans = []

for i in range(N):

    nBlock = 0

    for b in Block[i]:

        if union.isSame(i, b):

            nBlock += 1

    ans.append(str(union.size(i) - 1 - len(Friend[i]) - nBlock))

print((' '.join(ans)))

class UnionFind:



    def __init__(self, n):

        self.p, self.d = [-1] * n, [0] * n



    def find(self, x):

        if self.p[x] < 0:

            return x

        else:

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

            return self.p[x]



    def isSame(self, x, y):

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



    def unite(self, x, y):

        if self.isSame(x, y):

            return

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



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

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

            self.p[y] = x

        else:

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

            self.p[x] = y

            if self.d[x] == self.d[y]:

                self.d[y] += 1



    def size(self, x):

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





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

Frd, Blk = {i: [] for i in range(N)}, {i: [] for i in range(N)}



uni = UnionFind(N)

for _ in range(M):

    A, B = list(map(int, input().split()))

    uni.unite(A - 1, B - 1)

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

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

for _ in range(K):

    C, D = list(map(int, input().split()))

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

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



ans = []

for i in range(N):

    nBlk = sum([1 for b in Blk[i] if uni.isSame(i, b)])

    ans.append(str(uni.size(i) - 1 - len(Frd[i]) - nBlk))

print((' '.join(ans)))

class UnionFind:
    def __init__(self, n):
        # parent[x] < 0 means x is root and abs(parent[x]) == size[x]
        self.parent, self.depth = [-1] * n, [0] * n

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

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

    def unite(self, x, y):
        if self.isSame(x, y):
            return
        x, y = self.find(x), self.find(y)
        if self.depth[x] > self.depth[y]:
            self.parent[x] += self.parent[y]
            self.parent[y] = x
        else:
            self.parent[y] += self.parent[x]
            self.parent[x] = y
            if self.depth[x] == self.depth[y]:
                self.depth[y] += 1

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


N, M, K = list(map(int, input().split()))
Friend, Block = {i: [] for i in range(N)}, {i: [] for i in range(N)}
union = UnionFind(N)
for _ in range(M):
    A, B = list(map(int, input().split()))
    union.unite(A - 1, B - 1)
    Friend[A - 1].append(B - 1)
    Friend[B - 1].append(A - 1)
for _ in range(K):
    C, D = list(map(int, input().split()))
    Block[C - 1].append(D - 1)
    Block[D - 1].append(C - 1)
ans = []
for i in range(N):
    nBlock = 0
    for b in Block[i]:
        if union.isSame(i, b):
            nBlock += 1
    ans.append(str(union.size(i) - 1 - len(Friend[i]) - nBlock))
print((" ".join(ans)))

class UnionFind:
    def __init__(self, n):
        self.p, self.d = [-1] * n, [0] * n

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

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

    def unite(self, x, y):
        if self.isSame(x, y):
            return
        x, y = self.find(x), self.find(y)
        if self.d[x] > self.d[y]:
            self.p[x] += self.p[y]
            self.p[y] = x
        else:
            self.p[y] += self.p[x]
            self.p[x] = y
            if self.d[x] == self.d[y]:
                self.d[y] += 1

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


N, M, K = list(map(int, input().split()))
Frd, Blk = {i: [] for i in range(N)}, {i: [] for i in range(N)}
uni = UnionFind(N)
for _ in range(M):
    A, B = list(map(int, input().split()))
    uni.unite(A - 1, B - 1)
    Frd[A - 1].append(B - 1)
    Frd[B - 1].append(A - 1)
for _ in range(K):
    C, D = list(map(int, input().split()))
    Blk[C - 1].append(D - 1)
    Blk[D - 1].append(C - 1)
ans = []
for i in range(N):
    nBlk = sum([1 for b in Blk[i] if uni.isSame(i, b)])
    ans.append(str(uni.size(i) - 1 - len(Frd[i]) - nBlk))
print((" ".join(ans)))

-        # parent[x] < 0 means x is root and abs(parent[x]) == size[x] -        self.parent, self.depth = [-1] * n, [0] * n +        self.p, self.d = [-1] * n, [0] * n -        if self.parent[x] < 0: +        if self.p[x] < 0: -            self.parent[x] = self.find(self.parent[x]) -            return self.parent[x] +            self.p[x] = self.find(self.p[x]) +            return self.p[x] -        if self.depth[x] > self.depth[y]: -            self.parent[x] += self.parent[y] -            self.parent[y] = x +        if self.d[x] > self.d[y]: +            self.p[x] += self.p[y] +            self.p[y] = x -            self.parent[y] += self.parent[x] -            self.parent[x] = y -            if self.depth[x] == self.depth[y]: -                self.depth[y] += 1 +            self.p[y] += self.p[x] +            self.p[x] = y +            if self.d[x] == self.d[y]: +                self.d[y] += 1 -        return -self.parent[self.find(x)] +        return -self.p[self.find(x)] -Friend, Block = {i: [] for i in range(N)}, {i: [] for i in range(N)} -union = UnionFind(N) +Frd, Blk = {i: [] for i in range(N)}, {i: [] for i in range(N)} +uni = UnionFind(N) -    union.unite(A - 1, B - 1) -    Friend[A - 1].append(B - 1) -    Friend[B - 1].append(A - 1) +    uni.unite(A - 1, B - 1) +    Frd[A - 1].append(B - 1) +    Frd[B - 1].append(A - 1) -    Block[C - 1].append(D - 1) -    Block[D - 1].append(C - 1) +    Blk[C - 1].append(D - 1) +    Blk[D - 1].append(C - 1) -    nBlock = 0 -    for b in Block[i]: -        if union.isSame(i, b): -            nBlock += 1 -    ans.append(str(union.size(i) - 1 - len(Friend[i]) - nBlock)) +    nBlk = sum([1 for b in Blk[i] if uni.isSame(i, b)]) +    ans.append(str(uni.size(i) - 1 - len(Frd[i]) - nBlk))