#include <iostream>
#include <vector>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <ranges>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;

using i64 = long long;

int N, M;

std::vector<std::vector<int>> G;

struct V {
    int use = 0;
    int no = 0;
};

V rec(int v, int p) {
    V x;
    x.use += 1;
    for(auto u: G[v]) {
        if(u < N) continue;
        if(u == p) continue;
        auto y = rec(u, v);
        x.use += std::min(y.use, y.no);
        x.no += y.use;
    }
    return x;
}

int main() {
    std::cin >> N >> M;
    G.resize(N + M);
    for(int i = 0; i < N + M; i++) {
        int a, b;
        std::cin >> a >> b;
        if(a < N && b < N) continue;
        G[a].push_back(b);
        G[b].push_back(a);
    }

    std::vector dp(N, std::vector(2, std::vector<int>(2, 1e9)));
    V ze = rec(0, -1);
    dp[0][0][0] = ze.no;
    dp[0][1][1] = ze.use;
    for(int i = 1; i < N; i++) {
        V x = rec(i, -1);
        for(int z = 0; z < 2; z++) {
            for(int v = 0; v < 2; v++) {
                if(v == 1) {
                    dp[i][z][0] = std::min(dp[i][z][0], dp[i - 1][z][v] + x.no);
                }
                dp[i][z][1] = std::min(dp[i][z][1], dp[i - 1][z][v] + x.use);
            }
        }
    }
    std::cout << std::min({ dp[N - 1][1][0], dp[N - 1][1][1], dp[N - 1][0][1] }) << std::endl;
}