//doar in scop de testare

#include <iostream>
#include <bits/stdc++.h>
 
using namespace std;
 
ifstream f ("biconex.in");
ofstream g ("biconex.out");
 
vector<int> v[100005], dft, low;
vector <vector <int>> c;
stack <pair <int, int> > sk;
int n, m;
 
void punct_de_articulatie(int x, int y)
{
   vector<int> con;
   int tx, ty;
 
   //toti copiii lui x din stiva fac parte din componenta conexa
   while(tx != x || ty!=y)
   {
       tx=sk.top().first;
       ty=sk.top().second;
 
       sk.pop();
 
       con.push_back(tx);
       con.push_back(ty);
   }
 
   c.push_back(con);
}
 
void DFS (int x, int parent, int k)
{
   dft[x]=k;
   low[x]=k;
 
   for(int i=0; i<v[x].size(); i++)  //parcurc toti vecinii lui x
   {
       //conditia 1: nu o iau pe muchii de intoarcere
       //conditia 2: vecinul nu este vizitat
 
       if(v[x][i]!=parent && dft[v[x][i]]==-1)
       {
           //pun muchia pe care ma duc in stiva
           sk.push(make_pair(x, v[x][i]));
 
           DFS(v[x][i], x, k+1);  //fac dfs pe vecinul ales
 
           //daca copiii lui x au tutut sa ajunga intr-un nod doar prin o muchie de intparcere
           //inseamna ca si x poate, coborand putin si luand acceas muchie
 
           low[x]=min(low[x], low[v[x][i]]);
 
           if(low[v[x][i]]>=dft[x])  //contitia ca x sa fie punct de articulatie
               punct_de_articulatie(x, v[x][i]);
       }
       else
        if(dft[v[x][i]]!=-1)  //daca nodul e deja vizitat inseamna ca asta e o muchie de intoarcere
        {
           low[x]=min(low[x], dft[v[x][i]]);//asa ca fac update la low
        }
   }
}
 
int main()
{
   f>>n>>m;//citest nr de noduri si de muchii
 
   for(int i=0; i<m; i++)//citesc toae muchiile si le pun in lista de adiacenta
   {
       int x, y;
       f>>x>>y;
 
       v[x].push_back(y);
       v[y].push_back(x);
   }
 
   dft.resize(n+1);  //dft[x] va fi al catelea nod a fost x in parcurgerea dfs
   dft.assign(n+1, -1);  //deocamdata toatenodurile au valoarea -1, adica nu au fost vizitate
 
   low.resize(n+1);  //low[x] va fi dft[p] unde p este cel mai  de sus nod la care se poate ajunge
 
   //din x, traversand doar o muchie de intoarcere
 
   DFS(1, 0, 0);
 
   g<<c.size()<<"\n";
 
   for(int i=0; i< c.size(); i++)
   {
       sort( c[i].begin(), c[i].end() );
 
       c[i].erase( unique( c[i].begin(), c[i].end() ), c[i].end() );
 
       for(int j=0; j<c[i].size(); j++)
           g<<c[i][j]<<" ";
 
       g<<"\n";
   }
}