#!/usr/bin/env pypy3
def I(): return int(input())
def MI(): return 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() def I(): return int(input()) I def MI(): return map(int, input().split()) MI def LI(): return list(map(int, input().split())) LI 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:
        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()}
        
     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

         __init__ """
            N:要素数
            root:各要素の親要素の番号を格納するリスト.
                 ただし, root[x] < 0 ならその頂点が根で-root[x]が木の要素数.
            rank:ランク
            """ self.N = N self.N self N N self.root = [-1] * N self.root self root [-1] * N [-1] -1 N self.rank = [0] * N self.rank self rank [0] * N [0] 0 N self self N: int N def __repr__(self):
            return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

         __repr__ return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) '\n'.join '\n' join '{}: {}'.format(r, self.members(r)) '{}: {}'.format '{}: {}' format r self.members(r) self.members self members r self self 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

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

         self.root[x] < 0 self.root[x] self.root self root x 0 return x x while self.root[x] >= 0:
                    x = self.root[x]
                 self.root[x] >= 0 self.root[x] self.root self root x 0 x = self.root[x] x self.root[x] self.root self root x return x x self self x: int 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

         union """x,yが属する木をunion""" x = self.find(x) x self.find(x) self.find self find x y = self.find(y) y self.find(y) self.find 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

         x == y x y return elif self.rank[x] > self.rank[y]:
                self.root[x] += self.root[y]
                self.root[y] = x
             self.rank[x] > self.rank[y] self.rank[x] self.rank self rank x self.rank[y] self.rank self rank y self.root[x] += self.root[y] self.root[x] self.root self root x self.root[y] self.root self root y self.root[y] = x self.root[y] self.root self root y x self.root[y] += self.root[x] self.root[y] self.root self root y self.root[x] self.root self root x self.root[x] = y self.root[x] self.root self root x y if self.rank[x] == self.rank[y]:
                    self.rank[y] += 1

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

         same """xとyが同じグループに属するかどうか""" return self.find(x) == self.find(y) self.find(x) == self.find(y) self.find(x) self.find self find x self.find(y) self.find self find y self self x: int x y: int y def count(self, x):
            """頂点xが属する木のサイズを返す"""
            return - self.root[self.find(x)]

         count """頂点xが属する木のサイズを返す""" return - self.root[self.find(x)] - self.root[self.find(x)] self.root[self.find(x)] self.root self root self.find(x) self.find self find x self self x x def members(self, x):
            """xが属する木の要素を列挙"""
            _root = self.find(x)
            return [i for i in range(self.N) if self.find == _root]

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

         roots """森の根を列挙""" i for i, x in enumerate(self.root) if x < 0 for i, x in enumerate(self.root) if x < 0 i x enumerate(self.root) enumerate self.root self root x < 0 x 0 if x < 0 i return [i for i, x in enumerate(self.root) if x < 0] [i for i, x in enumerate(self.root) if x < 0] self self def group_count(self):
            """連結成分の数"""
            return len(self.roots())

         group_count """連結成分の数""" return len(self.roots()) len(self.roots()) len self.roots() self.roots self roots self self def all_group_members(self):
            """{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す"""
            return {r: self.members(r) for r in self.roots()}
        
     all_group_members """{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す""" r: self.members(r) for r in self.roots() for r in self.roots() r self.roots() self.roots self roots for r in self.roots() r self.members(r) self.members self members r return {r: self.members(r) for r in self.roots()} {r: self.members(r) for r in self.roots()} self self N,M,K=MI() N MI() MI M K uf=UnionFind(N) uf UnionFind(N) UnionFind N F=[0]*N F [0]*N [0] 0 N B=[0]*N B [0]*N [0] 0 N for i in range(M):
        a,b=MI()
        a-=1
        b-=1
        F[a]+=1
        F[b]+=1
        uf.union(a,b)
        
     i range(M) range M a,b=MI() a MI() MI b a-=1 a 1 b-=1 b 1 F[a]+=1 F[a] F a 1 F[b]+=1 F[b] F b 1 uf.union(a,b) uf.union 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
        
     i range(K) range K a,b=MI() a MI() MI b a-=1 a 1 b-=1 b 1 if uf.same(a,b):
            B[a]+=1
            B[b]+=1
        
     uf.same(a,b) uf.same uf same a b B[a]+=1 B[a] B a 1 B[b]+=1 B[b] B b 1 ans=[] ans [] for i in range(N):
        aaa=uf.count(i)-1
        aaa-=F[i]+B[i]
        ans.append(aaa)
        

        
     i range(N) range N aaa=uf.count(i)-1 aaa uf.count(i)-1 uf.count(i) uf.count uf count i 1 aaa-=F[i]+B[i] aaa F[i]+B[i] F[i] F i B[i] B i ans.append(aaa) ans.append ans append aaa print(' '.join(map(str, ans))) print ' '.join(map(str, ans)) ' '.join ' ' join map(str, ans) map str ans main() main def MI(): return map(int, input().split()) def MI(): return map(int, input().split()) MI def I(): return int(input()) def I(): return int(input()) I def LI(): return list(map(int, input().split())) def LI(): return list(map(int, input().split())) LI 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))) 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(input())
def MI(): return 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()
