/*
 * PA 2010
 * Laborator 7 - Aplicatii DFS
 *
 * Determinarea componentelor tare conexe
 *
 */

#include <cstdio> // daca vreti sa folositi printf, scanf
#include <iostream>
#include <fstream>
#include <vector>               
#include <stack>

using namespace std;

#define min(a, b) ((a) < (b) ? (a) : (b))
 
enum culoare_t {ALB, GRI, NEGRU};
typedef vector<int> *graf_t; 
 
int n, m;
graf_t G; // lista de adiacents
stack<int> S;

// Pentru retinerea solutiei si afisarea ei la sfarsit
vector <vector<int> > sol;
vector<int> crtcomp;

// In plus pentru Kosaraju
culoare_t *cul;
graf_t GT; // Lista de adiacenta a grafului transpus

// In plus pentru Tarjan 
int indx = 0;
int *idx, *lowlink;
bool *onstack;

void read_data(const char *filename)
{
	ifstream fin;
	int x, y;
	fin.open(filename);
	fin >> n >> m;
	G = new vector<int>[n];
	GT = new vector<int>[n]; // doar pentru Kosaraju
	for (int i = 0; i < m; i++) {
		fin >> x >> y;
		x--; y--; // indxare de la 0
		G[x].push_back(y);
		GT[y].push_back(x);
	}
}

/* Kosaraju */
void dfs(int v, graf_t lst)
{
	cul[v] = GRI;
	for (int i = 0; i < lst[v].size(); i++) {
		int u = lst[v][i];
    		if (cul[u] == ALB)
			dfs(u, lst);
	}
	cul[v] = NEGRU;
	S.push(v);
}                      

void dfsT(int v, graf_t lst)
{
	cul[v] = GRI;

	// TODO: adaugare nod la noua componenta conexa (afisare)
	//crtcomp.insert(crtcomp.begin(),v);
	crtcomp.push_back(v);
	
	for (int i = 0; i < lst[v].size(); i++) {
		int u = lst[v][i];
    		if (cul[u] == ALB)
			dfsT(u, lst);
	}
	cul[v] = NEGRU;
}                      

void ctc_kosaraju()
{
	int i;
	// Alocari memorie
	cul = new culoare_t[n];

	// TODO
	for (i = 0; i < n; i++) cul[i] = ALB;
	for (i = 0; i < n; i++) 
		if (cul[i] == ALB)
		{	
			dfs(i, G);			
		}
	for (i = 0; i < n; i++) cul[i] = ALB;
	
	while (!S.empty())
	{
		i = S.top();
		S.pop();
		if (cul[i] == ALB)
		{
			crtcomp.clear();
			//crtcomp.erase(crtcomp.begin(), crtcomp.end());
			dfsT(i, GT);
			sol.push_back(crtcomp);
		}
	}

	// Dezalocari memorie
	delete[] cul;
}

/* Tarjan */
void tarjan(int v)
{
	// TODO
	int i, u;
	idx[v]	=	indx;
	lowlink[v]	=	indx;
	indx++;
	S.push(v);
	onstack[v]	=	true;
	for ( i = 0; i < G[v].size(); i++)
	{
		u = G[v][i];
		if (idx[u] == -1)
		{
			tarjan(u);
			if (lowlink[v] > lowlink[u])
				lowlink[v] = lowlink[u];
		}
		else
		{
			if (onstack[u] == true)
			{
				if (lowlink[v] > idx[u])
					lowlink[v] = idx[u];
			}
		}
	}
	
	if (lowlink[v] == idx[v])
	{
		//crtcomp.erase(crtcomp.begin(), crtcomp.end());
		crtcomp.clear();
		do
		{
			u = S.top();
			S.pop();
			onstack[u] = false;
			crtcomp.push_back(u);
			if (u == v) break;
		} while (u != v);
		sol.push_back(crtcomp);
	}
}
		
void ctc_tarjan()
{
	int i;
	// Alocari memorie
	idx = new int[n];
	lowlink = new int[n];
	onstack = new bool[n];

	// TODO
	indx = 0;
	for ( i = 0; i<n; i++)
	{
		idx[i]	=	-1;
		lowlink[i]	=	i;
		onstack[i]	=	false;
	}
	
	while (!S.empty()) S.pop();
	for (i=0; i<n; i++)
		if (idx[i]	==	-1)
			tarjan(i);
	
	
	// Dezalocari memorie
	delete[] idx;
	delete[] lowlink;
	delete[] onstack;
}

// Afiseaza solutia daca a fost retinuta in "sol"
// (+ exemplu folosire iteratori)
void print_sol(const char *filename)
{
	ofstream fout;
	fout.open(filename);
	fout << sol.size() << endl;
	vector<vector<int> >::iterator s;
	for (s = sol.begin(); s != sol.end(); s++) {
		vector<int>::iterator v;
		for (v = s->begin(); v != s->end(); v++)
			fout << *v + 1 << " ";
		fout << endl;
	}
	fout.close();
}

void free_data()
{
	delete[] G;
	delete[] GT; // doar pentru Kosaraju
}

int main(int argc, char *argv[])
{   
    	if (argc >= 2)
		read_data(argv[2]);
	else
		read_data("ctc.in");

	// TODO: implementare ctc_kosaraju sau ctc_tarjan
	//ctc_kosaraju();
	 ctc_tarjan();
	
	if (argc >= 3)
		print_sol(argv[3]);
	else
		print_sol("ctc.out");

	free_data();

	return 0;
}