const int maxn = 500;
vector<int> edge[maxn];
int ma[maxn], T, vis[maxn], n, m;
// 1 ~ n : left, n+1 ~ m : right
bool dfs(int now) {
	if (exchange(vis[now], T) == T) return false;
	for (int u : edge[now])
		if (!ma[u] || dfs(ma[u]))
			return ma[u] = now, ma[now] = u;
	return false;
}
int get_max_matching() {
	int res = 0;
	for (int i = 1;i <= n;++i)
		res += (!ma[i] && (++T, dfs(i)));
	return res;
}

int ma[maxn], lst[maxn], side[maxn], fid[maxn], n;
vector<int> edge[maxn];
 
void augment(int x, int y) {
	while (x) {
		int pa = ma[x];
		ma[x] = y, ma[y] = x;
		y = pa, x = lst[y];
	}
}

int find_lca(int x, int y) {
	static int T, vis[maxn];
	for (++T; ; swap(x, y)) {
		if (x && exchange(vis[x], T) == T) 
			return x;
		x = fid[lst[ma[x]]];
	}
	return -1;
}

bool bfs(int rt) {
#define qpush(x) (side[x] = 0, togo.push(x))
    memset(side, -1, sizeof(side));
    queue<int> togo;
    qpush(rt);
    auto flower = [&](int x, int y, int lca) {
        while (x != lca) {
            if (side[x] == 1) qpush(x);
            lst[x] = y;
            fid[x] = fid[y] = lca;
            x = ma[x], y = lst[x];
        }
    };
    while (!togo.empty()) {
        int now = togo.front();
        togo.pop();
        for (int u : edge[now]) 
            if (side[u] == -1) {
                side[u] = 1;
                lst[u] = now;
                if (!ma[u])
                    return augment(now, u), true;
                qpush(ma[u]);
            }
            else if (!side[u]) {
                int lca = find_lca(u, now);
                flower(u, now, lca);
                flower(now, u, lca);
            }
    }
    return false;
}
 

int max_matching() {
	iota(fid, fid+n+1, 0);
	int res = 0;
	for (int i = 1;i <= n;++i)
		res += !ma[i] && bfs(i);
	return res;
}