/*

    LibreOJ #6000. 「网络流 24 题」搭配飞行员

    二分图最大匹配

    Dinic最大流 + 当前弧优化

*/

#include <cstring>

#include <cstdio>

#include <queue>

#define Max 10000

#define INF 1e5

int read (int &now)

{

    now = ;

    register char word = getchar ();

    while (word < '' || word > '')

        word = getchar ();

    while (word >= '' && word <= '')

    {

        now = now *  + word - '';

        word = getchar ();

    }

    if (now >= )

        return ;

}

inline int min (int a, int b)

{

    return a < b ? a : b;

}

class Net_Flow_Type

{

    private :

        int __to[Max << ], __next[Max << ];

        int __flow[Max << ];

        int edge_list[Max];

        int Edge_Count;

        int deep[Max], __tech_[Max];

        int T;

        int Answer;

    public :

        Net_Flow_Type ()

        {

            Edge_Count = ;

        }

        inline void Insert_edge (int from, int to)

        {

            Edge_Count ++;

            __to[Edge_Count] = to;

            __next[Edge_Count] = edge_list[from];

            edge_list[from] = Edge_Count;

            Edge_Count ++;

            __to[Edge_Count] = from;

            __next[Edge_Count] = edge_list[to];

            edge_list[to] = Edge_Count;

            __flow[Edge_Count - ] = ;

            __flow[Edge_Count] = ;

        }

        bool Bfs (int Start, int End)

        {

            std :: queue <int> Queue;

            Queue.push (Start);

            memset (deep, -, sizeof deep);

            int now;

            for (deep[Start] = ; !Queue.empty (); Queue.pop ())

            {

                now = Queue.front ();

                for (int i = edge_list[now]; i; i = __next[i])

                    if (__flow[i] && deep[__to[i]] == -)

                    {

                        deep[__to[i]] = deep[now] + ;

                        if (__to[i] == End)

                            return true;

                        Queue.push (__to[i]);

                    }

            } 

            return deep[End] != -;

        }

        int Flowing (int now, int flow)

        {

            if (now == T || flow <= )

                return flow;

            int res = , pos = ;

            for (int i = __tech_[now]; i; i = __next[i])

            {

                if (deep[__to[i]] != deep[now] +  || __flow[i] <= )

                    continue;

                res = Flowing (__to[i], min (flow, __flow[i]));

                if (res > )

                {

                    flow -= res;

                    pos += res;

                    __flow[i] -= res;

                    __flow[i ^ ] += res;

                    if (__flow[i])

                        __tech_[now] = i;

                    if (flow == )

                        return pos;

                }

            }

            return pos;

        }

        int Dinic (int Start, int End)

        {

            for (T = End; Bfs (Start, End); )

            {

                memcpy (__tech_, edge_list, sizeof edge_list);

                Answer += Flowing (Start, INF);

            }

            return Answer;

        }

};

int N, M;

Net_Flow_Type Make;

int main (int argc, char *argv[])

{

    read (N);

    read (M);

    int S = N + , T = N + ;

    for (int i = ; i <= M; i ++)

        Make.Insert_edge (S, i);

    for (int i = M + ; i <= N; i ++)

        Make.Insert_edge (i, T);

    for (int x, y; scanf ("%d %d", &x, &y) == ; Make.Insert_edge (x, y));

    printf ("%d", Make.Dinic (S, T));

    return ;

}