#!/usr/bin/env pypy3

def I(): return int(eval(input()))

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

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



################

class UnionFind():

    """

    parents : 親要素(findしない場合は根ではないことの注意)，根の場合は"-(要素数）"

    find(x):要素xの属するグループの根を返す

    size(x):要素xの属するグループの要素数を返す

    same(x,y):x,yが同じグループに属しているか返す

    members(x):要素xが属するグループに属する要素をリストで返す

    roots:全ての根の要素を返す

    group_count():グループの数を返す

    all_group_members():{根要素：[そのグループに含まれる要素のリスト]}の辞書を返す

    """

    def __init__(self, n):

        self.n = n

        self.parents = [-1] * n



    def find(self, x):

        if self.parents[x] < 0:

            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



    def size(self, x):

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



    def same(self, x, y):

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



    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 x < 0]



    def group_count(self):

        return len(self.roots())



    def all_group_members(self):

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



    def __str__(self):

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

    

################



def main():

    mod=10**9+7

    N,M,K=MI()

    uf = UnionFind(N)

    cnt=[0]*N#友達の数

    for i in range(M):

        a,b=MI()

        a-=1

        b-=1

        cnt[a]+=1

        cnt[b]+=1

        uf.union(a,b)

        

    blo=[0]*N#同じユニオン内でブロックしているかず

    for i in range(K):

        c,d=MI()

        c-=1

        d-=1

        if uf.same(c,d):

            blo[c]+=1

            blo[d]+=1

    ans=[0]*N    

    for i in range(N):

        ans[i]=uf.size(i) - cnt[i]-blo[i]-1

        

    print((' '.join(map(str, ans))))

        

    



main()

#!/usr/bin/env pypy3

def I(): return int(eval(input()))

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

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



def main():

    class UnionFind:

        def __init__(self, N: int):

            """

            N:要素数

            root:各要素の親要素の番号を格納するリスト.

                 ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.

            rank:ランク

            """

            self.N = N

            self.root = [-1] * N

            self.rank = [0] * N



        def __repr__(self):

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



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

            """頂点xの根を見つける"""

            if self.root[x] < 0:

                return x

            else:

                while self.root[x] >= 0:

                    x = self.root[x]

                return x



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

            """x,yが属する木をunion"""

            # 根を比較する

            # すでに同じ木に属していた場合は何もしない.

            # 違う木に属していた場合はrankを見てくっつける方を決める.

            # rankが同じ時はrankを1増やす

            x = self.find(x)

            y = self.find(y)

            if x == y:

                return

            elif self.rank[x] > self.rank[y]:

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

                self.root[y] = x

            else:

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

                self.root[x] = y

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

                    self.rank[y] += 1



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

            """xとyが同じグループに属するかどうか"""

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



        def count(self, x):

            """頂点xが属する木のサイズを返す"""

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



        def members(self, x):

            """xが属する木の要素を列挙"""

            _root = self.find(x)

            return [i for i in range(self.N) if self.find == _root]



        def roots(self):

            """森の根を列挙"""

            return [i for i, x in enumerate(self.root) if x < 0]



        def group_count(self):

            """連結成分の数"""

            return len(self.roots())



        def all_group_members(self):

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

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

        

    N,M,K=MI()

    uf=UnionFind(N)

    F=[0]*N

    B=[0]*N

    

    for i in range(M):

        a,b=MI()

        a-=1

        b-=1

        F[a]+=1

        F[b]+=1

        uf.union(a,b)

        

    for i in range(K):

        a,b=MI()

        a-=1

        b-=1

        if uf.same(a,b):

            B[a]+=1

            B[b]+=1

        

    ans=[]

    for i in range(N):

        aaa=uf.count(i)-1

        aaa-=F[i]+B[i]

        ans.append(aaa)

        



        

    print((' '.join(map(str, ans))))



main()

#!/usr/bin/env pypy3
def I():
    return int(eval(input()))


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


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


################
class UnionFind:
    """
    parents : 親要素(findしない場合は根ではないことの注意)，根の場合は"-(要素数）"
    find(x):要素xの属するグループの根を返す
    size(x):要素xの属するグループの要素数を返す
    same(x,y):x,yが同じグループに属しているか返す
    members(x):要素xが属するグループに属する要素をリストで返す
    roots:全ての根の要素を返す
    group_count():グループの数を返す
    all_group_members():{根要素：[そのグループに含まれる要素のリスト]}の辞書を返す
    """

    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            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

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

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

    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 x < 0]

    def group_count(self):
        return len(self.roots())

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

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


################
def main():
    mod = 10**9 + 7
    N, M, K = MI()
    uf = UnionFind(N)
    cnt = [0] * N  # 友達の数
    for i in range(M):
        a, b = MI()
        a -= 1
        b -= 1
        cnt[a] += 1
        cnt[b] += 1
        uf.union(a, b)
    blo = [0] * N  # 同じユニオン内でブロックしているかず
    for i in range(K):
        c, d = MI()
        c -= 1
        d -= 1
        if uf.same(c, d):
            blo[c] += 1
            blo[d] += 1
    ans = [0] * N
    for i in range(N):
        ans[i] = uf.size(i) - cnt[i] - blo[i] - 1
    print((" ".join(map(str, ans))))


main()

#!/usr/bin/env pypy3
def I():
    return int(eval(input()))


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


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


def main():
    class UnionFind:
        def __init__(self, N: int):
            """
            N:要素数
            root:各要素の親要素の番号を格納するリスト.
                 ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
            rank:ランク
            """
            self.N = N
            self.root = [-1] * N
            self.rank = [0] * N

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

        def find(self, x: int) -> int:
            """頂点xの根を見つける"""
            if self.root[x] < 0:
                return x
            else:
                while self.root[x] >= 0:
                    x = self.root[x]
                return x

        def union(self, x: int, y: int) -> int:
            """x,yが属する木をunion"""
            # 根を比較する
            # すでに同じ木に属していた場合は何もしない.
            # 違う木に属していた場合はrankを見てくっつける方を決める.
            # rankが同じ時はrankを1増やす
            x = self.find(x)
            y = self.find(y)
            if x == y:
                return
            elif self.rank[x] > self.rank[y]:
                self.root[x] += self.root[y]
                self.root[y] = x
            else:
                self.root[y] += self.root[x]
                self.root[x] = y
                if self.rank[x] == self.rank[y]:
                    self.rank[y] += 1

        def same(self, x: int, y: int) -> bool:
            """xとyが同じグループに属するかどうか"""
            return self.find(x) == self.find(y)

        def count(self, x):
            """頂点xが属する木のサイズを返す"""
            return -self.root[self.find(x)]

        def members(self, x):
            """xが属する木の要素を列挙"""
            _root = self.find(x)
            return [i for i in range(self.N) if self.find == _root]

        def roots(self):
            """森の根を列挙"""
            return [i for i, x in enumerate(self.root) if x < 0]

        def group_count(self):
            """連結成分の数"""
            return len(self.roots())

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

    N, M, K = MI()
    uf = UnionFind(N)
    F = [0] * N
    B = [0] * N
    for i in range(M):
        a, b = MI()
        a -= 1
        b -= 1
        F[a] += 1
        F[b] += 1
        uf.union(a, b)
    for i in range(K):
        a, b = MI()
        a -= 1
        b -= 1
        if uf.same(a, b):
            B[a] += 1
            B[b] += 1
    ans = []
    for i in range(N):
        aaa = uf.count(i) - 1
        aaa -= F[i] + B[i]
        ans.append(aaa)
    print((" ".join(map(str, ans))))


main()

-################ -class UnionFind: -    """ -    parents : 親要素(findしない場合は根ではないことの注意)，根の場合は"-(要素数）" -    find(x):要素xの属するグループの根を返す -    size(x):要素xの属するグループの要素数を返す -    same(x,y):x,yが同じグループに属しているか返す -    members(x):要素xが属するグループに属する要素をリストで返す -    roots:全ての根の要素を返す -    group_count():グループの数を返す -    all_group_members():{根要素：[そのグループに含まれる要素のリスト]}の辞書を返す -    """ +def main(): +    class UnionFind: +        def __init__(self, N: int): +            """ +            N:要素数 +            root:各要素の親要素の番号を格納するリスト. +                 ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数. +            rank:ランク +            """ +            self.N = N +            self.root = [-1] * N +            self.rank = [0] * N -    def __init__(self, n): -        self.n = n -        self.parents = [-1] * n +        def __repr__(self): +            return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots()) -    def find(self, x): -        if self.parents[x] < 0: -            return x -        else: -            self.parents[x] = self.find(self.parents[x]) -            return self.parents[x] +        def find(self, x: int) -> int: +            """頂点xの根を見つける""" +            if self.root[x] < 0: +                return x +            else: +                while self.root[x] >= 0: +                    x = self.root[x] +                return 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 +        def union(self, x: int, y: int) -> int: +            """x,yが属する木をunion""" +            # 根を比較する +            # すでに同じ木に属していた場合は何もしない. +            # 違う木に属していた場合はrankを見てくっつける方を決める. +            # rankが同じ時はrankを1増やす +            x = self.find(x) +            y = self.find(y) +            if x == y: +                return +            elif self.rank[x] > self.rank[y]: +                self.root[x] += self.root[y] +                self.root[y] = x +            else: +                self.root[y] += self.root[x] +                self.root[x] = y +                if self.rank[x] == self.rank[y]: +                    self.rank[y] += 1 -    def size(self, x): -        return -self.parents[self.find(x)] +        def same(self, x: int, y: int) -> bool: +            """xとyが同じグループに属するかどうか""" +            return self.find(x) == self.find(y) -    def same(self, x, y): -        return self.find(x) == self.find(y) +        def count(self, x): +            """頂点xが属する木のサイズを返す""" +            return -self.root[self.find(x)] -    def members(self, x): -        root = self.find(x) -        return [i for i in range(self.n) if self.find(i) == root] +        def members(self, x): +            """xが属する木の要素を列挙""" +            _root = self.find(x) +            return [i for i in range(self.N) if self.find == _root] -    def roots(self): -        return [i for i, x in enumerate(self.parents) if x < 0] +        def roots(self): +            """森の根を列挙""" +            return [i for i, x in enumerate(self.root) if x < 0] -    def group_count(self): -        return len(self.roots()) +        def group_count(self): +            """連結成分の数""" +            return len(self.roots()) -    def all_group_members(self): -        return {r: self.members(r) for r in self.roots()} +        def all_group_members(self): +            """{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す""" +            return {r: self.members(r) for r in self.roots()} -    def __str__(self): -        return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots()) - - -################ -def main(): -    mod = 10**9 + 7 -    cnt = [0] * N  # 友達の数 +    F = [0] * N +    B = [0] * N -        cnt[a] += 1 -        cnt[b] += 1 +        F[a] += 1 +        F[b] += 1 -    blo = [0] * N  # 同じユニオン内でブロックしているかず -        c, d = MI() -        c -= 1 -        d -= 1 -        if uf.same(c, d): -            blo[c] += 1 -            blo[d] += 1 -    ans = [0] * N +        a, b = MI() +        a -= 1 +        b -= 1 +        if uf.same(a, b): +            B[a] += 1 +            B[b] += 1 +    ans = [] -        ans[i] = uf.size(i) - cnt[i] - blo[i] - 1 +        aaa = uf.count(i) - 1 +        aaa -= F[i] + B[i] +        ans.append(aaa)