output_description: Print the answers in order, with space in between.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M K
      A_1 B_1
      \vdots
      A_M B_M
      C_1 D_1
      \vdots
      C_K D_K
attempt: """
  Friend Suggestions
  """
  
  import sys
  
  input = lambda: sys.stdin.readline().rstrip()
  
  
  class Vertex:
      """A Vertex is a node in a graph."""
  
      def __init__(self, label=""):
          self.label = label
  
      def __repr__(self):
          return f"V{self.label}"
  
      __str__ = __repr__
  
  
  class Edge(tuple):
      """An Edge is a list of two vertices."""
  
      def __new__(cls, *vs):
          """The Edge constructor takes two vertices."""
          if len(vs) != 2:
              raise ValueError("Edges must connect exactly two vertices.")
          return tuple.__new__(cls, vs)
  
      def __repr__(self):
          return f"Edge_{repr(self[0])}_{repr(self[1])}"
  
      __str__ = __repr__
  
  
  class Graph(dict):
      """A Graph is a dictionary of dictionaries.
      For vertices a and b, graph[a][b] maps
      to the edge that connects a->b, if it exists."""
  
      def __init__(self, vs, es):
          """Creates a new graph.
          vs: list of vertices;
          es: list of edges.
          """
          super().__init__()
          for v in vs:
              self.add_vertex(v)
          for e in es:
              self.add_edge(e)
  
      def add_vertex(self, v):
          """Add a vertex to the graph."""
          self[v] = {}
  
      def add_edge(self, e):
          """Adds and edge to the graph by adding an entry in both directions."""
          v, w = e
          self[v][w] = e
          self[w][v] = e
  
      def vertices(self):
          """returns a list of the vertices in graph"""
          vs = []
          for v in self.keys():
              vs.append(v)
          return vs
  
      def out_vertices(self, v):
          """returns a list of adjacent vertices of the (v)"""
          return self[v].keys()
  
      def out_edges(self, v):
          """returns a list of edges connected to the (v)"""
          return self[v].values()
  
      def is_connected(self):
          """returns True if the Graph is conneted and False otherwise"""
          vertices = self.vertices()
          closed = self.BFS(vertices[0])
          return len(vertices) == len(closed)
  
      def closed_vertices(self, v):
          return self.BFS(v)
  
      def BFS(self, v):
          """search graph by a BFS: breadth-first-search"""
          worklist = [v]
          closed = []
          while worklist:
              visited = worklist.pop(0)
              closed.append(visited)
              vs = self.out_vertices(visited)
              vs = [v for v in vs if not (v in closed or v in worklist)]
              worklist.extend(vs)
          return closed
  
  
  def main():
      N, M, K = map(int, input().split())
      ans = [-1] * N
  
      friend = [list(map(int, input().split())) for _ in range(M)]
      blocks = [list(map(int, input().split())) for _ in range(K)]
  
      nodes = [Vertex(str(v)) for v in range(N)]
      edges = [Edge(nodes[edge[0] - 1], nodes[edge[1] - 1]) for edge in friend]
      g = Graph(nodes, edges)
  
      for i, v in enumerate(nodes):
          closed_graph_list = [str(x) for x in g.closed_vertices(v)]
          closed_graph_list.remove(str(v))
          connected_vertices = [str(x) for x in list(g.out_vertices(v))]
          candidates = list(set(closed_graph_list) - set(connected_vertices))
          ans[i] = candidates
  
      for block_rel in blocks:
          block_a = block_rel[0] - 1
          block_b = block_rel[1] - 1
          if f"V{block_b}" in ans[block_a]:
              ans[block_a].remove(f"V{block_b}")
          if f"V{block_a}" in ans[block_b]:
              ans[block_b].remove(f"V{block_a}")
  
      print(*[len(i) for i in ans])
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  An SNS has N users - User 1, User 2, \cdots, User N.
  
  Between these N users, there are some relationships - M _friendships_ and K
  _blockships_.
  
  For each i = 1, 2, \cdots, M, there is a bidirectional friendship between User
  A_i and User B_i.
  
  For each i = 1, 2, \cdots, K, there is a bidirectional blockship between User
  C_i and User D_i.
  
  We define User a to be a _friend candidate_ for User b when all of the
  following four conditions are satisfied:
  
    * a \neq b.
    * There is not a friendship between User a and User b.
    * There is not a blockship between User a and User b.
    * There exists a sequence c_0, c_1, c_2, \cdots, c_L consisting of integers between 1 and N (inclusive) such that c_0 = a, c_L = b, and there is a friendship between User c_i and c_{i+1} for each i = 0, 1, \cdots, L - 1.
  
  For each user i = 1, 2, ... N, how many friend candidates does it have?
samples: [{"input": "4 4 1\n    2 1\n    1 3\n    3 2\n    3 4\n    4 1", "output": "0 1 0 1\n    \n\nThere is a friendship between User 2 and 3, and between 3 and 4. Also, there\nis no friendship or blockship between User 2 and 4. Thus, User 4 is a friend\ncandidate for User 2.\n\nHowever, neither User 1 or 3 is a friend candidate for User 2, so User 2 has\none friend candidate.\n\n* * *"}, {"input": "5 10 0\n    1 2\n    1 3\n    1 4\n    1 5\n    3 2\n    2 4\n    2 5\n    4 3\n    5 3\n    4 5", "output": "0 0 0 0 0\n    \n\nEveryone is a friend of everyone else and has no friend candidate.\n\n* * *"}, {"input": "10 9 3\n    10 1\n    6 7\n    8 2\n    2 5\n    8 4\n    7 3\n    10 9\n    6 4\n    5 8\n    2 6\n    7 5\n    3 1", "output": "1 3 5 4 3 3 3 3 1 0"}]