#include <fstream>
#include <vector>
#include <stack>
#include <algorithm>
#define DIM 100010
using namespace std;
ifstream f("biconex.in");
ofstream g("biconex.out");
int n, m, i, j, v[DIM], Low[DIM], k, x, y, b, u;
// Low[i] = nivelul minim pe care pot ajunge plecand recursivitatea din nodul i
vector<int> L[DIM];
vector <int>  B[DIM];

stack< pair<int, int> > st;

/*struct stiva{
    int x;
    int y;
} s[DIM];
*/
inline int minim(int x, int y){
    return (x<y?x:y);
}

void dfs(int x, int niv, int tata){
    v[x]=1;
    Low[x] = niv;
    for(int i=0; i<L[x].size(); i++) {
        if( v[ L[x][i] ]==0) {
            st.push(make_pair(x, L[x][i]));
/*            u++;
            s[u].x=x;
            s[u].y=L[x][i];
*/
            dfs(L[x][i], niv+1, x);
            // verific nivelul minim care se poate atinge plecand pe muchia (x, L[x][i])
            if (niv <= Low[ L[x][i]  ]){
                // muchia x L[x][i] a provocat o componenta biconexa
                // scot din stiva toate muchiile pana la muchia x L[x][i] inclusiv
                b++;
                pair<int, int> Aux;

                do{
                    Aux=st.top();
                    st.pop();
                    //u--;
                    B[b].push_back(Aux.first);
                    B[b].push_back(Aux.second);

                }
                while (Aux.first!=x || Aux.second!=L[x][i]);
            }
        }
        if (L[x][i] != tata)
            Low[x]=minim(Low[x], Low[ L[x][i] ]);
    }
}

int main(){
    f>>n>>m;
    for(i=1; i<=m; i++)
    {
        f>>x>>y;
        L[x].push_back(y);
        L[y].push_back(x);
    }
    dfs(1, 1, 0);
    g<<b<<"\n";
    for(i=1; i<=b; i++)
    {
        sort(B[i].begin(), B[i].end());
        g<<B[i][0]<<' ';
        for(j=1; j<B[i].size(); j++)
            if(B[i][j]!=B[i][j-1])
                g<<B[i][j]<<' ';
        g<<"\n";
    }
    return 0;
}