/*
	Se dă un graf orientat G = (V, E). O componentă tare conexă a grafului orientat G este o mulţime maximală de vârfuri U inclusă în V, 
astfel încât, pentru fiecare pereche de vârfuri u şi v din U avem atât drum de la u la v cât şi drum de la v la u. 
Cu alte cuvinte, vâfurile u şi v sunt accesibile unul din celălalt.

Cerinţă
	Dându-se un graf orientat G = (V, E) se cere să se determine componentele sale tare conexe.

Date de intrare
	Fişierul de intrare ctc.in conţine pe prima linie două numere naturale N si M ce reprezintă numărul de noduri din G şi numărul muchiilor. 
Pe următoarele M linii se vor afla câte două numere naturale x şi y, separate prin spaţiu, reprezentând muchia orientată (x, y).

Date de ieşire
	În fişierul de ieşire ctc.out se va afişa pe prima linie un singur număr reprezentând numărul componentelor tare conexe. 
Pe fiecare din următoarele linii se va scrie câte o componentă tare conexă prin enumerarea nodurilor componente. Acestea pot fi afişate în orice ordine.
*/

#include <fstream>
#include <vector>
#include <stack>

using namespace std; 

ifstream fin("ctc.in"); 
ofstream fout("ctc.out");

int nrNoduri, nrMuchii; 

vector<vector<int>>graf; //lista de adiacenta a grafului 
vector<vector<int>>grafTranspus; //lista de adiacenta a grafului transpus

vector<bool> vizitat;

stack <int> ordine; 

vector<vector<int>> componenteTareConexe; 
int nrComponente; 

void DFSInainte(int nodInceput)
{
	vizitat[nodInceput] = true;

	for (int indiceVecin = 0; indiceVecin < graf[nodInceput].size(); indiceVecin++)
		if (!vizitat[graf[nodInceput][indiceVecin]])
			DFSInainte(graf[nodInceput][indiceVecin]); 

	ordine.push(nodInceput); 
}

void DFSInapoi(int nodInceput)
{
	vizitat[nodInceput] = false; 
	componenteTareConexe[nrComponente - 1].push_back(nodInceput);
	
	for (int indiceVecin = 0; indiceVecin < grafTranspus[nodInceput].size(); indiceVecin++)
		if (vizitat[grafTranspus[nodInceput][indiceVecin]])
			DFSInapoi(grafTranspus[nodInceput][indiceVecin]); 

}

int main()
{
	/*idee: */
	fin >> nrNoduri >> nrMuchii; 

	graf.resize(nrNoduri+1); 
	grafTranspus.resize(nrNoduri+1);  

	for (int nr = 0; nr <= nrMuchii; nr++)
	{
		int nodIntrare, nodIesire; 
		fin >> nodIntrare >> nodIesire; 

		graf[nodIntrare].push_back(nodIesire); 
		grafTranspus[nodIesire].push_back(nodIntrare); 

	}

	vizitat.assign(nrNoduri + 1, false); 

	for (int nod = 1; nod <= nrNoduri; nod++)
		if (!vizitat[nod])
			DFSInainte(nod); 

	while (!ordine.empty())
	{
		if (vizitat[ordine.top()])
		{
			nrComponente++;
			componenteTareConexe.resize(nrComponente);
			DFSInapoi(ordine.top());
		}

		ordine.pop(); 

	}

	fout << nrComponente << '\n'; 
	for (int nr = 0; nr < nrComponente; nr++)
	{
		for (int i = 0; i < componenteTareConexe[nr].size(); i++)
			fout << componenteTareConexe[nr][i] << " ";
		fout << '\n'; 
	}



		




}