/**************************************************************

    Problem:

    User: BLADEVIL

    Language: Pascal

    Result: Accepted

    Time: ms

    Memory: kb

****************************************************************/

//By BLADEVIL

var

    n, m                        :longint;

    pre, other                  :array[..] of longint;

    last                        :array[..] of longint;

    l                           :longint;

    flag                        :array[..] of boolean;

    dfn, low                    :array[..] of longint;

    time                        :longint;

    tot                         :longint;

    stack                       :array[..] of longint;

    key                         :array[..] of longint;

    size                        :array[..] of longint;

    full                        :longint;

    father                      :array[..] of longint;

function min(a,b:longint):longint;

begin

    if a>b then min:=b else min:=a;

end;   

procedure connect(x,y:longint);

begin

    inc(l);

    pre[l]:=last[x];

    last[x]:=l;

    other[l]:=y;

end;

procedure init;

var

    i                           :longint;

    x, y                        :longint;

begin

    read(n,m);

    for i:= to m do

    begin

        read(x,y);

        connect(y,x);

    end;

end;

procedure dfs(x:longint);

var

    q, p                        :longint;

    cur                         :longint;

begin

    inc(time);

    dfn[x]:=time;

    low[x]:=time;

    flag[x]:=true;

    inc(tot);

    stack[tot]:=x;

    q:=last[x];

    while q<> do

    begin

        p:=other[q];

        if dfn[p]= then

        begin

            dfs(p);

            low[x]:=min(low[x],low[p]);

        end else

        if flag[p] then low[x]:=min(low[x],dfn[p]);

        q:=pre[q];

    end;

    cur:=-;

    if dfn[x]=low[x] then

    begin

        while cur<>x do

        begin

            cur:=stack[tot];

            dec(tot);

            flag[cur]:=false;

            key[cur]:=x+n;

            inc(size[key[cur]]);

        end;

    end;

end;

procedure main;

var

    i                           :longint;

    q, p                        :longint;

begin

    for i:= to n do if dfn[i]= then dfs(i);

    for i:= to n do

    begin

        q:=last[i];

        while q<> do

        begin

            p:=other[q];

            if key[i]<>key[p] then

            begin

                connect(key[i],key[p]);

                father[key[p]]:=key[i];

            end;

            q:=pre[q];

        end;

    end;

    full:=-;

    for i:= to n do

    begin

        if (father[key[i]]=) and (full=-) then full:=key[i];

        if (father[key[i]]=) and (full<>-) and (full<>key[i]) then

        begin

            writeln();

            exit;

        end;

    end;

    writeln(size[full]);

end;

begin

    init;

    main;

end.