output_description: Print the largest size of the matching.
input_description: |X| |Y| |E|
      x0 y0
      x1 y1
      :
      x|E|-1 y|E|-1
      
  
  |X| and |Y| are the number of vertices in X and Y respectively, and |E| is the
  number of edges in the graph G. The vertices in X are named with the numbers
  0, 1,..., |X|-1, and vertices in Y are named with the numbers 0, 1,..., |Y|-1,
  respectively.
  
  xi and yi are the node numbers from X and Y respectevely which represent the
  end-points of the i-th edge.
attempt: # -*- coding: utf-8 -*-
  """
  Matching - Bipartite Matching
  http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_7_A&lang=jp
  
  """
  import sys
  from sys import stdin
  from collections import namedtuple
  
  input = stdin.readline
  edge = namedtuple("edge", ["to", "cap", "rev"])
  
  
  def add_edge(G, f, t, c):
      G[f].append(edge(t, c, len(G[t])))
      G[t].append(edge(f, 0, len(G[f]) - 1))
  
  
  def dfs(G, used, v, t, f):
      if v == t:
          return f
      used[v] = True
      for i in range(len(G[v])):
          e = G[v][i]
          if (not used[e.to]) and (e.cap > 0):
              d = dfs(G, used, e.to, t, min(f, e.cap))
              if d > 0:
                  G[v][i] = edge(e.to, e.cap - d, e.rev)
                  G[e.to][e.rev] = edge(
                      G[e.to][e.rev].to, G[e.to][e.rev].cap + d, G[e.to][e.rev].rev
                  )
                  return d
      return 0
  
  
  def max_flow(G, V, s, t):
      used = [False] * V
      flow = 0
      while True:
          for i in range(len(used)):
              used[i] = False
          f = dfs(G, used, s, t, float("inf"))
          if f == 0:
              return flow
          flow += f
  
  
  def main(args):
      """
      - 追加したソースノードID: 0
      - Xグループ: 1〜X
      - Yグループ: X+1〜X+Y
      - 追加したシンクノードID: X+Y+1
      として、ノード0 → X+Y+1 への最大流を求める
      """
      X, Y, E = map(int, input().split())
      G = [[] for _ in range(X + Y + 2)]
  
      for li in range(E):
          x, y = map(int, input().split())
          add_edge(G, 0, x, 1)
          add_edge(G, y, X + Y + 1, 1)
          add_edge(G, x + 1, X + y + 1, 1)
  
      ans = max_flow(G, X + Y + 2, 0, X + Y + 1)  #  ソースとシンク間の最大流
      print(ans)
  
  
  if __name__ == "__main__":
      main(sys.argv[1:])
  
problem_description: Bipartite Matching
  
  A bipartite graph G = (V, E) is a graph in which the vertex set V can be
  divided into two disjoint subsets X and Y such that every edge e ∈ E has one
  end point in X and the other end point in Y.
  
  A matching M is a subset of edges such that each node in V appears in at most
  one edge in M.
  
  Given a bipartite graph, find the size of the matching which has the largest
  size.
samples: [{"input": "3 4 6\n    0 0\n    0 2\n    0 3\n    1 1\n    2 1\n    2 3", "output": "3"}]