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



class UF():

  def __init__(self, N):

    self._parent=[n for n in range(0, N)]

    self._size=[1] * N



  def find_root(self, x):

    if self._parent[x]==x:return x

    self._parent[x]=self.find_root(self._parent[x])

    return self._parent[x]



  def unite(self, x, y):

    gx=self.find_root(x)

    gy=self.find_root(y)

    if gx==gy:return



    if self._size[gx]<self._size[gy]:

      self._parent[gx]=gy

      self._size[gy]+=self._size[gx]

    else:

      self._parent[gy]=gx

      self._size[gx]+=self._size[gy]



  def size(self, x):

    return self._size[self.find_root(x)]



  def samegroup(self, x, y):

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



  def groupnum(self):

    N=len(self._parent)

    ans=0

    for i in range(N):

      if self.find_root(i)==i:

        ans+=1

    return ans



cf=[[] for i in range(n)]

cb=[[] for i in range(n)]



UFa=UF(n)

UFb=UF(n)

for i in range(m):

  x,y=list(map(int,input().split()))

  UFa.unite(x-1,y-1)

  UFb.unite(x-1,y-1)

  cf[x-1].append(y-1)

  cf[y-1].append(x-1)

UFa.groupnum()



for i in range(k):

  x,y=list(map(int,input().split()))

  cb[x-1].append(y-1)

  cb[y-1].append(x-1)



ans=[]

for i in range(n):

  x=(UFa.size(i)-1)-len(cf[i])

  for j in range(len(cb[i])):

    if UFa.samegroup(i,cb[i][j]):

      x-=1

  ans.append(str(x))

print((' '.join(ans)))
import sys

input=sys.stdin.readline

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



class UF():

  def __init__(self, N):

    self._parent=[n for n in range(0, N)]

    self._size=[1] * N



  def find_root(self, x):

    if self._parent[x]==x:return x

    self._parent[x]=self.find_root(self._parent[x])

    return self._parent[x]



  def unite(self, x, y):

    gx=self.find_root(x)

    gy=self.find_root(y)

    if gx==gy:return



    if self._size[gx]<self._size[gy]:

      self._parent[gx]=gy

      self._size[gy]+=self._size[gx]

    else:

      self._parent[gy]=gx

      self._size[gx]+=self._size[gy]



  def size(self, x):

    return self._size[self.find_root(x)]



  def samegroup(self, x, y):

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



  def groupnum(self):

    N=len(self._parent)

    ans=0

    for i in range(N):

      if self.find_root(i)==i:

        ans+=1

    return ans



cf=[[] for i in range(n)]

cb=[[] for i in range(n)]



UFa=UF(n)

UFb=UF(n)

for i in range(m):

  x,y=list(map(int,input().split()))

  UFa.unite(x-1,y-1)

  UFb.unite(x-1,y-1)

  cf[x-1].append(y-1)

  cf[y-1].append(x-1)

UFa.groupnum()



for i in range(k):

  x,y=list(map(int,input().split()))

  cb[x-1].append(y-1)

  cb[y-1].append(x-1)



ans=[]

for i in range(n):

  x=(UFa.size(i)-1)-len(cf[i])

  for j in range(len(cb[i])):

    if UFa.samegroup(i,cb[i][j]):

      x-=1

  ans.append(str(x))

print((' '.join(ans)))
n, m, k = list(map(int, input().split()))


class UF:
    def __init__(self, N):
        self._parent = [n for n in range(0, N)]
        self._size = [1] * N

    def find_root(self, x):
        if self._parent[x] == x:
            return x
        self._parent[x] = self.find_root(self._parent[x])
        return self._parent[x]

    def unite(self, x, y):
        gx = self.find_root(x)
        gy = self.find_root(y)
        if gx == gy:
            return
        if self._size[gx] < self._size[gy]:
            self._parent[gx] = gy
            self._size[gy] += self._size[gx]
        else:
            self._parent[gy] = gx
            self._size[gx] += self._size[gy]

    def size(self, x):
        return self._size[self.find_root(x)]

    def samegroup(self, x, y):
        return self.find_root(x) == self.find_root(y)

    def groupnum(self):
        N = len(self._parent)
        ans = 0
        for i in range(N):
            if self.find_root(i) == i:
                ans += 1
        return ans


cf = [[] for i in range(n)]
cb = [[] for i in range(n)]
UFa = UF(n)
UFb = UF(n)
for i in range(m):
    x, y = list(map(int, input().split()))
    UFa.unite(x - 1, y - 1)
    UFb.unite(x - 1, y - 1)
    cf[x - 1].append(y - 1)
    cf[y - 1].append(x - 1)
UFa.groupnum()
for i in range(k):
    x, y = list(map(int, input().split()))
    cb[x - 1].append(y - 1)
    cb[y - 1].append(x - 1)
ans = []
for i in range(n):
    x = (UFa.size(i) - 1) - len(cf[i])
    for j in range(len(cb[i])):
        if UFa.samegroup(i, cb[i][j]):
            x -= 1
    ans.append(str(x))
print((" ".join(ans)))

import sys

input = sys.stdin.readline
n, m, k = list(map(int, input().split()))


class UF:
    def __init__(self, N):
        self._parent = [n for n in range(0, N)]
        self._size = [1] * N

    def find_root(self, x):
        if self._parent[x] == x:
            return x
        self._parent[x] = self.find_root(self._parent[x])
        return self._parent[x]

    def unite(self, x, y):
        gx = self.find_root(x)
        gy = self.find_root(y)
        if gx == gy:
            return
        if self._size[gx] < self._size[gy]:
            self._parent[gx] = gy
            self._size[gy] += self._size[gx]
        else:
            self._parent[gy] = gx
            self._size[gx] += self._size[gy]

    def size(self, x):
        return self._size[self.find_root(x)]

    def samegroup(self, x, y):
        return self.find_root(x) == self.find_root(y)

    def groupnum(self):
        N = len(self._parent)
        ans = 0
        for i in range(N):
            if self.find_root(i) == i:
                ans += 1
        return ans


cf = [[] for i in range(n)]
cb = [[] for i in range(n)]
UFa = UF(n)
UFb = UF(n)
for i in range(m):
    x, y = list(map(int, input().split()))
    UFa.unite(x - 1, y - 1)
    UFb.unite(x - 1, y - 1)
    cf[x - 1].append(y - 1)
    cf[y - 1].append(x - 1)
UFa.groupnum()
for i in range(k):
    x, y = list(map(int, input().split()))
    cb[x - 1].append(y - 1)
    cb[y - 1].append(x - 1)
ans = []
for i in range(n):
    x = (UFa.size(i) - 1) - len(cf[i])
    for j in range(len(cb[i])):
        if UFa.samegroup(i, cb[i][j]):
            x -= 1
    ans.append(str(x))
print((" ".join(ans)))

+import sys + +input = sys.stdin.readline