#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(int)(n); i++)
#define all(v) v.begin(), v.end()
#define PRINT(v) for (auto x : (v)) cout <<x <<" " ; cout <<endl;
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using mat = vector<vector<ll>>;
const ll MOD = 1000000007;
const ll INF = 10000000000000000;
vector<int> x4 = {0, 1, 0, -1}, x8 = {0, 1, 1, 1, 0, -1, -1, -1};
vector<int> y4 = {1, 0, -1, 0}, y8 = {1, 1, 0, -1, -1, -1, 0, 1};
template<class T> inline bool chmin(T& a, T b){if (a>b){a = b; return true;}return false;}
template<class T> inline bool chmax(T& a, T b){if (a<b){a = b; return true;}return false;}
template<class T> inline T powerM(T a,T b){if (b==0) return 1;
T tmp = powerM(a,b/2); if (b%2==0) return tmp*tmp%MOD; else return tmp*tmp%MOD*a%MOD; }
template<class T> inline T power(T a,T b,T m){ if (b==0) return 1;
  T tmp = power(a,b/2,m); if (b%2==0) return tmp*tmp%m; else return tmp*tmp%m*a%m; }
template<class T> inline T gcd(T a, T b){if (b==0) return a; return gcd(b, a%b);}
template<class T> inline T lcm(T a, T b){return a / gcd(a,b) * b;}
// ax+by=gcd(a,b)を解く
template<class T> inline T extgcd(T a,T b,T &x,T &y){if (b==0){x=1; y=0; return a;} T d=extgcd(b,a%b,y,x); y -= a/b*x; return d;}
void hey(){ cout <<"hey" <<endl; }

template<class T> struct edge { int to; T cost;};


// Dinic法：構造体--------------------------------------------
// 最大流問題に。O( |E||V|^2 ) だが非常に高速に動作することが多い
// Dinic g(n); してからadd_edge(u, v, c) しまくり
// 同じやつでverifyはした 

// 辺を表す構造体 {行き先, 容量, 逆辺}
struct edgeflow {int to,cap,rev; };

struct Dinic {
  int V;
  vector<vector<edgeflow>> G; // グラフの隣接リスト表現
  vector<int> level; // sからの距離
  vector<int> iter;  // どこまで調べ終わったか

  Dinic(int n) : G(n), level(n, -1), iter(n, 0) {}

  // fromからtoへ向かう容量capの辺をグラフに追加する
  void add_edge(int from, int to, int cap){
    // 割と特殊なやり方をしてる
    G[from].push_back((edgeflow){to, cap, (int)G[to].size()});
    G[to].push_back((edgeflow){from, 0, (int)G[from].size() - 1});
  }

  // sからの最短距離をBFSで計算し、距離が増加する向きの辺のみからなるグラフを作成
  void bfs(int s) {
    level.assign(level.size(), -1);
    queue<int> que;
    level[s] = 0;   que.push(s);
    while (!que.empty()) {
      int v = que.front(); que.pop();
      for (int i=0; i<G[v].size(); i++){
        edgeflow &e = G[v][i];
        if (e.cap > 0 && level[e.to] < 0){
          level[e.to] = level[v] + 1;
          que.push(e.to);
        }
      }
    }
  }

  // 増加パスをDFSで探す
  int dfs(int v, int t, int f) {
    if (v == t) return f;
    for (int &i=iter[v]; i<G[v].size(); i++){
      edgeflow &e = G[v][i];        // 容量を更新するのでアドレス
      if (e.cap > 0 && level[v] < level[e.to]){
        int d = dfs(e.to, t, min(f, e.cap));
        if (d > 0){
          e.cap -= d;               // 使った分容量を減らす
          G[e.to][e.rev].cap += d;  // 使った分逆辺の容量を増やす
          return d;
        }
      }
    }
    return 0;
  }

  // sからtへの最大流を求める
  int max_flow(int s, int t){
    int flow = 0;
    while (true){
      bfs(s);
      if (level[t] < 0) return flow;
      iter.assign(iter.size(), 0);
      int f;
      while ((f = dfs(s, t, INT_MAX/2)) > 0) flow += f;
    }
  }
};

int main() {
  int X,Y,E; cin >>X >>Y >>E;
  Dinic g(X+Y+2);
  const int ssource = X+Y;
  const int ssink = X+Y+1;
  rep(i, X){
    int x = i;
    g.add_edge(ssource, x, 1);
  }
  rep(i, Y){
    int y = i + X;
    g.add_edge(y, ssink, 1);
  }
  rep(i, E){
    int x,y; cin >>x >>y; y += X;
    g.add_edge(x, y, 1);
  }
  int res = g.max_flow(ssource, ssink);
  cout <<res <<endl;
}



Measured memory_bytes: 3292