#include <iostream>
#include <fstream>

using namespace std ;

ifstream f ( "ctc.in" ) ;
ofstream g ( "ctc.out" ) ;

const int maxn = 10000 ;

struct structura1
{
  int Punct ;
  bool inceput ;
} ;

struct structura2
{
  int intrare , iesire ;
} ;

structura1 Conexitate [ maxn ] ;
structura2 A [ maxn ] ;

int legaturiDirect [ maxn ] [ maxn ] , legaturiTranspus [ maxn ] [ maxn ] ;
int iesiri [ maxn ] ;
bool sel [ maxn ] ;
int nrNoduri , nrLegaturi , Contor1 , Contor2 , Contor ;

void citireFisier ( )
{
  f >> nrNoduri ;
  f >> nrLegaturi ;
  int i = 1 , j , k ;
  for ( i ; i <= nrLegaturi ; i++ )
  {
    f >> j ;
    f >> k ;
    legaturiDirect [ j ] [ ++legaturiDirect [ j ] [ 0 ] ] = k ;
    legaturiTranspus [ k ] [ ++legaturiTranspus [ k ] [ 0 ] ] = j ;
  }
}

void scriereFisier ( ) 
{
  int i = 1 ;
  for ( i ; i <= nrNoduri ; i++ )
  {
    if ( Conexitate [ i ] . inceput )
      g << endl ;
    g << Conexitate [ i ] . Punct << " " ;
  }
  g << endl ;
}

void afisareTest ( )
{
  int i = 1 , j ;
  for ( i ; i <= nrNoduri ; i++ )
  {
    cout << i << " este legat de urmatorii : " ;
    for ( j = 1 ; j <= legaturiDirect [ i ] [ 0 ] ; j++ )
    {
      cout << legaturiDirect [ i ] [ j ] << " " ;
    }
    cout << endl ;
  }
}

void parcurgereDirecta ( int Nod )
{
  sel [ Nod ] = true ;
  int i = 1 ;
  A [ Nod ] . intrare = ++Contor1 ;
  for ( i ; i <= legaturiDirect [ Nod ] [ 0 ] ; i++ )
  {
    if ( ! sel [ legaturiDirect [ Nod ] [ i ] ] )
      parcurgereDirecta ( legaturiDirect [ Nod ] [ i ] ) ;
  }
  A [ Nod ] . iesire = ++Contor1 ;
  iesiri [ ++Contor2 ] = Nod ;
}

void parcurgereInvers ( int Nod )
{
  sel [ Nod ] = ! sel [ Nod ] ;
  int i = 1 ;
  for ( i ; i <= legaturiTranspus [ Nod ] [ 0 ] ; i++ )
  {
    if ( sel [ legaturiTranspus [ Nod ] [ i ] ] )
      parcurgereInvers ( legaturiTranspus [ Nod ] [ i ] ) ;
  }
  Conexitate [ ++Contor1 ] . Punct = Nod ;
}

int main ( )
{
  citireFisier ( ) ;
  int i = 1 ;
  for ( i ; i <= nrNoduri ; i++)
    if ( ! sel [ i ] )
      parcurgereDirecta ( i ) ;
  Contor1 = 0 ;
  for ( i = Contor2 ; i > 0 ; i-- )
  {
    if ( sel [ iesiri [ i ] ] )
    {
      Contor++ ;
      Conexitate [ Contor1 + 1 ] . inceput = true ;
      parcurgereInvers ( iesiri [ i ] ) ;
    }
  }
  g << Contor ;
  scriereFisier ( ) ;
  f.close ( ) ;
  g.close ( ) ;
  return 0 ;
}