class unionfind():

    def __init__(self,n):
        #親番号<0なら根
        #根の場合、数値の絶対値が要素数
        self.par=[-1 for i in range(n)]
        
    def root(self,x):
        
        par=self.par
        if par[x]<0:
            return x
        else:
            self.x = self.root(par[x])
            return self.x
        
    def unite(self,x,y):
        #高いほうに低いほうをくっつける
        rx=self.root(x)
        ry=self.root(y)
        
        if rx==ry:
            return
        else:
            if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
            self.par[rx]+=self.par[ry]
            self.par[ry] = rx

            
    def same(self, x,y):
        return self.root(x) == self.root(y)
    
    def par_print(self):
        print(self.par)
        
    def count(self, x):
        return -self.par[self.root(x)]

n,m,k = map(int,input().split())

friend = [[] for i in range(n)]
block = [[] for i in range(n)]

uf = unionfind(n)

for i in range(m):
    
    a,b = map(int,input().split())
    a-=1
    b-=1
    
    friend[a].append(b)
    friend[b].append(a)
    
    uf.unite(a,b)
    
    
    
for i in range(k):
    
    a,b = map(int,input().split())
    a-=1
    b-=1
    
    block[a].append(b)
    block[b].append(a) 
    
    
for i in range(n):
    
    ans = uf.count(i)-1 -len(friend[i])
    
    for j in block[i]:
        if uf.same(i,j):
            ans -= 1
    
    print(ans, end = " ") class unionfind():

    def __init__(self,n):
        #親番号<0なら根
        #根の場合、数値の絶対値が要素数
        self.par=[-1 for i in range(n)]
        
    def root(self,x):
        
        par=self.par
        if par[x]<0:
            return x
        else:
            self.x = self.root(par[x])
            return self.x
        
    def unite(self,x,y):
        #高いほうに低いほうをくっつける
        rx=self.root(x)
        ry=self.root(y)
        
        if rx==ry:
            return
        else:
            if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
            self.par[rx]+=self.par[ry]
            self.par[ry] = rx

            
    def same(self, x,y):
        return self.root(x) == self.root(y)
    
    def par_print(self):
        print(self.par)
        
    def count(self, x):
        return -self.par[self.root(x)] unionfind def __init__(self,n):
        #親番号<0なら根
        #根の場合、数値の絶対値が要素数
        self.par=[-1 for i in range(n)]
        
     __init__ -1 for i in range(n) for i in range(n) i range(n) range n for i in range(n) -1 self.par=[-1 for i in range(n)] self.par self par [-1 for i in range(n)] self self n n def root(self,x):
        
        par=self.par
        if par[x]<0:
            return x
        else:
            self.x = self.root(par[x])
            return self.x
        
     root par=self.par par self.par self par if par[x]<0:
            return x
        else:
            self.x = self.root(par[x])
            return self.x
        
     par[x]<0 par[x] par x 0 return x x self.x = self.root(par[x]) self.x self x self.root(par[x]) self.root self root par[x] par x return self.x self.x self x self self x x def unite(self,x,y):
        #高いほうに低いほうをくっつける
        rx=self.root(x)
        ry=self.root(y)
        
        if rx==ry:
            return
        else:
            if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
            self.par[rx]+=self.par[ry]
            self.par[ry] = rx

            
     unite rx=self.root(x) rx self.root(x) self.root self root x ry=self.root(y) ry self.root(y) self.root self root y if rx==ry:
            return
        else:
            if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
            self.par[rx]+=self.par[ry]
            self.par[ry] = rx

            
     rx==ry rx ry return if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
             self.par[rx]>self.par[ry] self.par[rx] self.par self par rx self.par[ry] self.par self par ry rx,ry = ry,rx rx ry ry rx self.par[rx]+=self.par[ry] self.par[rx] self.par self par rx self.par[ry] self.par self par ry self.par[ry] = rx self.par[ry] self.par self par ry rx self self x x y y def same(self, x,y):
        return self.root(x) == self.root(y)
    
     same return self.root(x) == self.root(y) self.root(x) == self.root(y) self.root(x) self.root self root x self.root(y) self.root self root y self self x x y y def par_print(self):
        print(self.par)
        
     par_print print(self.par) print self.par self par self self def count(self, x):
        return -self.par[self.root(x)] count return -self.par[self.root(x)] -self.par[self.root(x)] self.par[self.root(x)] self.par self par self.root(x) self.root self root x self self x x n,m,k = map(int,input().split()) n map(int,input().split()) map int input().split() ().split () input split m k [] for i in range(n) for i in range(n) i range(n) range n for i in range(n) [] friend = [[] for i in range(n)] friend [[] for i in range(n)] [] for i in range(n) for i in range(n) i range(n) range n for i in range(n) [] block = [[] for i in range(n)] block [[] for i in range(n)] uf = unionfind(n) uf unionfind(n) unionfind n for i in range(m):
    
    a,b = map(int,input().split())
    a-=1
    b-=1
    
    friend[a].append(b)
    friend[b].append(a)
    
    uf.unite(a,b)
    
    
     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-=1 a 1 b-=1 b 1 friend[a].append(b) [a].append [a] friend a append b friend[b].append(a) [b].append [b] friend b append a uf.unite(a,b) uf.unite uf unite a b for i in range(k):
    
    a,b = map(int,input().split())
    a-=1
    b-=1
    
    block[a].append(b)
    block[b].append(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-=1 a 1 b-=1 b 1 block[a].append(b) [a].append [a] block a append b block[b].append(a) [b].append [b] block b append a for i in range(n):
    
    ans = uf.count(i)-1 -len(friend[i])
    
    for j in block[i]:
        if uf.same(i,j):
            ans -= 1
    
    print(ans, end = " ") i range(n) range n ans = uf.count(i)-1 -len(friend[i]) ans uf.count(i)-1 -len(friend[i]) uf.count(i)-1 uf.count(i) uf.count uf count i 1 len(friend[i]) len friend[i] friend i for j in block[i]:
        if uf.same(i,j):
            ans -= 1
    
     j block[i] block i if uf.same(i,j):
            ans -= 1
    
     uf.same(i,j) uf.same uf same i j ans -= 1 ans 1 print(ans, end = " ") print ans end = " " end " " block = [[] for i in range(n)] [[] for i in range(n)] block ans -= 1 1 ans b = map(int,input().split()) map(int,input().split()) b ans = uf.count(i)-1 -len(friend[i]) uf.count(i)-1 -len(friend[i]) ans a,b = map(int,input().split()) map(int,input().split()) a a-=1 1 a class unionfind():

    def __init__(self,n):
        #親番号<0なら根
        #根の場合、数値の絶対値が要素数
        self.par=[-1 for i in range(n)]
        
    def root(self,x):
        
        par=self.par
        if par[x]<0:
            return x
        else:
            self.x = self.root(par[x])
            return self.x
        
    def unite(self,x,y):
        #高いほうに低いほうをくっつける
        rx=self.root(x)
        ry=self.root(y)
        
        if rx==ry:
            return
        else:
            if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
            self.par[rx]+=self.par[ry]
            self.par[ry] = rx

            
    def same(self, x,y):
        return self.root(x) == self.root(y)
    
    def par_print(self):
        print(self.par)
        
    def count(self, x):
        return -self.par[self.root(x)] class unionfind():

    def __init__(self,n):
        #親番号<0なら根
        #根の場合、数値の絶対値が要素数
        self.par=[-1 for i in range(n)]
        
    def root(self,x):
        
        par=self.par
        if par[x]<0:
            return x
        else:
            self.x = self.root(par[x])
            return self.x
        
    def unite(self,x,y):
        #高いほうに低いほうをくっつける
        rx=self.root(x)
        ry=self.root(y)
        
        if rx==ry:
            return
        else:
            if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
            self.par[rx]+=self.par[ry]
            self.par[ry] = rx

            
    def same(self, x,y):
        return self.root(x) == self.root(y)
    
    def par_print(self):
        print(self.par)
        
    def count(self, x):
        return -self.par[self.root(x)] unionfind uf = unionfind(n) unionfind(n) uf n,m,k = map(int,input().split()) map(int,input().split()) n b-=1 1 b friend = [[] for i in range(n)] [[] for i in range(n)] friend m,k = map(int,input().split()) map(int,input().split()) m k = map(int,input().split()) map(int,input().split()) k b-=1 1 b b = map(int,input().split()) map(int,input().split()) b a,b = map(int,input().split()) map(int,input().split()) a a-=1 1 a
class unionfind():

    def __init__(self,n):
        #親番号<0なら根
        #根の場合、数値の絶対値が要素数
        self.par=[-1 for i in range(n)]
        
    def root(self,x):
        
        par=self.par
        if par[x]<0:
            return x
        else:
            self.x = self.root(par[x])
            return self.x
        
    def unite(self,x,y):
        #高いほうに低いほうをくっつける
        rx=self.root(x)
        ry=self.root(y)
        
        if rx==ry:
            return
        else:
            if self.par[rx]>self.par[ry]:
                rx,ry = ry,rx
                
            self.par[rx]+=self.par[ry]
            self.par[ry] = rx

            
    def same(self, x,y):
        return self.root(x) == self.root(y)
    
    def par_print(self):
        print(self.par)
        
    def count(self, x):
        return -self.par[self.root(x)]

n,m,k = map(int,input().split())

friend = [[] for i in range(n)]
block = [[] for i in range(n)]

uf = unionfind(n)

for i in range(m):
    
    a,b = map(int,input().split())
    a-=1
    b-=1
    
    friend[a].append(b)
    friend[b].append(a)
    
    uf.unite(a,b)
    
    
    
for i in range(k):
    
    a,b = map(int,input().split())
    a-=1
    b-=1
    
    block[a].append(b)
    block[b].append(a) 
    
    
for i in range(n):
    
    ans = uf.count(i)-1 -len(friend[i])
    
    for j in block[i]:
        if uf.same(i,j):
            ans -= 1
    
    print(ans, end = " ")
