#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;
ifstream f("biconex.in");
ofstream g("biconex.out");

typedef pair < int, int> edge;
int N, M, low[100005], found[100005], nr, dad[100005], x, y;
vector < int > G[100005], Part;
vector < edge > CritEdge, st;
vector < vector <int> > BCC;

template <class T>
inline void eliminaduplicate(vector < T > &v)
{
    sort(v.begin(), v.end());
    v.erase( unique(v.begin(), v.end()), v.end() );
}

void getbcc(edge M)
{
    vector <int> newbcc; edge E;
    do
    {
        E=st.back(); st.pop_back();
        newbcc.push_back(E.first); newbcc.push_back(E.second);
    }while (E!=M);
    eliminaduplicate(newbcc);
    BCC.push_back(newbcc);
}

void dfs(int nod)
{
    low[nod]=found[nod]=++nr;
    int sons=0;
    vector<int>::iterator it=G[nod].begin();
    for (; it!=G[nod].end(); ++it)
        if (!dad[*it])
        {
            dad[*it]=nod; st.push_back(edge(nod, *it));
            ++sons; dfs(*it);
            low[nod]=min(low[nod], low[*it]);

            if (low[*it]>=found[nod])
                getbcc(edge(nod, *it));

            if (low[*it]>=found[nod] && dad[nod]!=nod)
                Part.push_back(nod);

            if (low[*it]>found[nod])
                CritEdge.push_back(edge(nod, *it));
        }
        else if (dad[nod]!=*it)
            low[nod]=min(low[nod], found[*it]);

    if (sons>1 && dad[nod]==nod)
        Part.push_back(nod);
}

void solve()
{
    for (int i=1; i<=N; ++i)
        if (!dad[i]) dad[i]=i, dfs(i);
    eliminaduplicate(CritEdge);
}

void printBCC()
{
    g<<BCC.size()<<'\n';
    for (int i=0; i<(int)BCC.size(); ++i && g<<'\n')
        for (int j=0; j<(int)BCC[i].size(); ++j)
            g<<BCC[i][j]<<' ';
}

void printCE()
{
    g<<CritEdge.size()<<'\n';
    for (int i=0; i<(int)CritEdge.size(); ++i)
        g<<CritEdge[i].first<<' '<<CritEdge[i].second<<'\n';
}

void printPA()
{
    g<<Part.size()<<'\n';
    for (int i=0; i<(int)Part.size(); ++i)
        g<<Part[i]<<' '; g<<'\n';
}

int main()
{
    f>>N>>M;
    for (int i=1; i<=M; ++i)
    {
        f>>x>>y;
        G[x].push_back(y);
        G[y].push_back(x);
    }

    solve();
    printBCC();
    return 0;
}