#include <iostream>
#include <stack>
#include <vector>
using namespace std;
int k;
class Graf
{
private:
    int N;
    vector<int> *adiacenta;
    void dfs(int v, int vizitat[] );
    void dfs_fara_printare(int v, int vizitat[] );
    void OrderFilling (stack<int> &stiva, int n, int vizitat[]);

public:
    Graf(int n);

    Graf Transpus();

    void adaugare_muchie(int x, int y);
    void ctc();
};

Graf::Graf(int n)
{
    this->N=n+1;
    adiacenta= new vector<int>[n+1];
}

void Graf::dfs(int n, int vizitat[])
{
    vizitat[n] = 1;
    if (n!=0)
        cout<<n<<" ";

    for(int i= 0; i < adiacenta[n].size(); i++)
       {
           int urm = adiacenta[n][i];
           if(!vizitat[urm])
               dfs(urm,vizitat);
       }
}


void Graf::dfs_fara_printare(int n, int vizitat[])
{
    vizitat[n] = 1;
    for(int i= 0; i < adiacenta[n].size(); i++)
       {
           int urm = adiacenta[n][i];
           if(!vizitat[urm])
               dfs_fara_printare(urm,vizitat);
       }
}


Graf Graf::Transpus()
{
    Graf g(N);
   // cout<<"Test"<<endl;
	for (int v = 0; v < N; v++)
	{

		// Recur for all the vertices adjacent to this vertex
		vector<int>::iterator i;
		for(i = adiacenta[v].begin(); i != adiacenta[v].end(); ++i)
		{
			g.adiacenta[*i].push_back(v);
		}

	}

	return g;
}

void Graf::adaugare_muchie(int x, int y)
{
    adiacenta[x].push_back(y);
    //cout<<"Test"<<endl;
}

void Graf::OrderFilling (stack<int> &stiva, int n, int vizitat[])
{
   // cout<<"Test"<<endl;
    vizitat[n]= 1;
/*
    vector<int>::iterator i;
	for(i = adiacenta[n].begin(); i != adiacenta[n].end(); ++i)
		if(!vizitat[*i])
			OrderFilling(stiva, *i, vizitat);
   // cout<<"test"<<endl;
  */


    for(int i= 0; i < adiacenta[n].size(); i++)
       {
           int urm = adiacenta[n][i];
           if(!vizitat[urm])
               OrderFilling(stiva,urm,vizitat);
       }

    stiva.push(n);
}

void Graf::ctc()
{
    stack<int> stiva;
    int *vizitat = new int[N];

    for(int i = 0; i < N; i++)
		vizitat[i] = 0;
    //cout<<"test"<<endl;
    for(int i = 0; i < N; i++)
		if(vizitat[i] == 0)
			OrderFilling(stiva, i, vizitat);

    //cout<<"test"<<endl;
    Graf g1= Transpus();

    for (int i=0;i<N;i++)
        vizitat[i]=0;

    stack<int> copie_stiva = stiva;
    int* vizitat_copie = new int[N];
    for (int i=0;i<N;i++)
        vizitat_copie[i]=0;

    int k=0;
    while (stiva.empty() == false)
	{
		// Pop a vertex from stack
		int x = stiva.top();
		stiva.pop();

		// Print Strongly connected component of the popped vertex
		if (vizitat[x] == false)
		{
		    g1.dfs_fara_printare(x,vizitat);
		    k++;
		}

	}
	cout<<k-1<<endl;

    int k1=0;
	while (copie_stiva.empty() == false)
	{

		// Pop a vertex from stack
		int x = copie_stiva.top();
		copie_stiva.pop();

		// Print Strongly connected component of the popped vertex
		if (vizitat_copie[x] == false)
		{
			g1.dfs(x,vizitat_copie);

			k1++;
			cout << endl;
		}


	}
}

int main()
{
    Graf g(8);
	g.adaugare_muchie(1, 2);
	g.adaugare_muchie(2, 6);
	g.adaugare_muchie(6, 7);
	g.adaugare_muchie(7, 6);
	g.adaugare_muchie(3, 1);
	g.adaugare_muchie(3, 4);
	g.adaugare_muchie(2, 3);
	g.adaugare_muchie(4, 5);
	g.adaugare_muchie(5, 4);
	g.adaugare_muchie(6, 5);
	g.adaugare_muchie(5, 8);
	g.adaugare_muchie(8, 7);

	g.ctc();

    return 0;
}