#include <bits/stdc++.h>
#include <fstream>
using namespace std;

int ctc;
vector<int> ctcv[100001];
vector<int> drum;


void dfs(int node, vector<int> L[], vector<int> &viz, vector<int> &order, bool pos)
{
    viz[node] = 1;
    if(!pos) ctcv[ctc].push_back(node);

    for(auto elem: L[node])
    {
        if(!viz[elem])
        {
            dfs(elem, L, viz, order, pos);
        }
        //else ctcv[ctc].push_back(elem);
    }

    if(pos)
        order.push_back(node);
}

void afis1(ofstream &fout)
{
    fout << ctc << '\n';
    for(int i = 1; i <= ctc; i ++)
    {
        for(auto j: ctcv[i])
            fout << j << ' ';
        fout << '\n';
    }
}

void afis2(ofstream &fout)
{
    fout << ctc << '\n';
    for(int i = 1; i <= ctc; i ++)
    {
        for(auto j: ctcv[i])
            fout << i << ' ';
    }
}

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

    int n, m;
    fin >> n >> m;

    vector<int> L[n + 1];
    vector<int> LT[n + 1];
    vector<int> viz(n + 1, 0);

    vector<int> order;

    for(int i = 1; i <= m; i ++)
    {
        int x, y;
        fin >> x >> y;

        L[x].push_back(y);
        LT[y].push_back(x);
    }

    for(int i = 1; i <= n; i ++)
        if(viz[i] == 0) dfs(i, L, viz, order, true);

    for(int i = 1; i <= n; i ++) viz[i] = 0;

    reverse(order.begin(), order.end());

    for(auto i: order)
    {
        if(viz[i] == 0)
        {
            ctc ++;
            dfs(i, LT, viz, order, false);
        }
    }

    //afis1(fout);

    afis2(fout);
}


void dfs2(int node, vector<int> L[], vector<int>& viz, bool &pos, int parent)
{
    viz[node] = 1;
    if(!pos) return;

    for(auto elem: L[node])
    {
        if(!pos) break;
        if(viz[elem] == 0)
            dfs2(elem, L, viz, pos, node);
        else 
        {
            if(parent != elem)
            {
                pos = false;
                drum.push_back(elem);
                break;
            }
        }
    }

    drum.push_back(node); 
}

void detectare_ciclu()
{
    int n, m;

    cin >> n >> m;

    vector<int> L[n + 1];

    for(int i = 1; i <= m; i ++)
    {
        int x, y;
        cin >> x >> y;

        L[x].push_back(y);
        L[y].push_back(x);
    }

    vector<int> viz(n + 1, 0);
    bool pos = true;

    for(int i = 1; i <= n; i ++)
    {
        if(viz[i] == 0)
            dfs2(i, L, viz, pos, 0);
    }

    if(pos) cout << "IMPOSSIBLE";
    else{
        cout << drum.size() << '\n';
        for(auto d: drum)
            cout << d << ' ';
    }
}


void dfs3(int node, vector<int> L[], vector<int> &viz, vector<int> &order, bool& flag)
{
    if(!flag) return;
    viz[node] = 1;

    for(auto elem: L[node])
    {
        if(viz[elem] == 0)
            dfs3(elem, L, viz, order, flag);
        
        if(viz[elem] == 1) 
            flag = false;
    }

    order.push_back(node);
    viz[node] = 2;

}

void sortare_topologica()
{
    ifstream fin("sortaret.in");
    ofstream fout("sortaret.out");

    int n, m;

    fin >> n >> m;

    vector<int> L[n + 1];

    for(int i = 1; i <= m; i ++)
    {
        int x, y;

        fin >> x >> y;

        L[x].push_back(y);
    }

    for(int i = 1; i <= n; i ++)
        L[i].erase(unique(L[i].begin(), L[i].end()), L[i].end());

    vector<int> viz(n + 1, 0);
    vector<int> order;
    bool flag = true;

    for(int i = 1; i <= n; i ++)
    {
        if(viz[i] == 0)
        {
            dfs3(i, L, viz, order, flag);
        }
    }

    reverse(order.begin(), order.end());

    if(!flag) fout << "IMPOSSIBLE\n";
    //else 
        for(auto i: order)
            fout << i << ' ';
}


void dfs4(int node, vector<int> L[], vector<int>& viz, int cul, int parent, bool& flag)
{
    viz[node] = cul;

    for(auto elem: L[node])
    {
        if(viz[elem] == cul)
            flag = false;
        if(viz[elem] == 0)
        {
            dfs4(elem, L, viz, (cul + 1) % 3, node, flag);
        }
    }
}

void bipartit()
{
    int n, m;

    cin >> n >> m;

    vector<int> L[n + 1];

    for(int i = 1; i <= m; i ++)
    {
        int x, y;
        cin >> x >> y;

        L[x].push_back(y);
        L[y].push_back(x);
    }

    vector<int> viz(n + 1, 0);
    bool flag = true;

    for(int i = 1; i <= n; i ++)
    {
        if(viz[i] == 0)
            dfs4(i, L, viz, 1, 0, flag);
    }

    if(!flag) cout << "IMPOSSIBLE\n";
    else
        for(auto i: viz)
            cout << viz[i] << ' ';
}

int root, nr_fii;

void dfs5(int node, int parent, vector<int> L[], vector<int> &crit, vector<int> &niv, vector<int> &low)
{
    niv[node] = niv[parent] + 1;
    low[node] = niv[node];

    for(auto elem: L[node])
    {
        if(elem == parent) continue;

        if(niv[elem] != 0)
            low[node] = min(low[node], niv[elem]);
        else 
            {
                if(node == root)
                    nr_fii ++;
                dfs5(elem, node, L, crit, niv, low);

                low[node] = min(low[node], low[elem]);

                if(node != root && low[elem] >= niv[node])
                    crit[node] = 1;
            }
    }
}

void puncte_critice()
{
    int n, m;

    cin >> n >> m;

    while(n != 0 && m != 0)
    {
        int x, y;
        vector<int> L[n + 1];
        vector <int> crit(n + 1, 0);
        vector<int> niv(n + 1, 0);
        niv[0] = 0;
        vector<int> low(n + 1, 0);

        for(int i = 1; i <= m; i ++)
        {
            cin >> x >> y;

            L[x].push_back(y);
            L[y].push_back(x);
        }

        root = 1;
        nr_fii = 0;
        dfs5(root, 0, L, crit, niv, low);

        int nr_crit = 0;

        for(int i = 1; i <= n; i ++)
            if(crit[i]) nr_crit ++;

        cout << "Nr: " << nr_crit << '\n';

        cin >> n >> m;
    }
}


vector<vector<int>> componente;

void dfs6(int node, int parent, vector<int> L[], vector<pair<int, int>> &muchii, vector<int>& niv, vector<int>&low, int &comp)
{
    niv[node] = niv[parent] + 1;
    low[node] = niv[node];

    for(auto elem: L[node])
    {
        if(elem == parent) continue;

        if(niv[elem] != 0) low[node] = min(low[node], niv[elem]);
        else
        {
            if(node == root) nr_fii ++;

            muchii.push_back({node, elem});
            dfs6(elem, node, L, muchii, niv, low, comp);

            low[node] = min(low[node], low[elem]);

            if(low[elem] >= niv[node])
            {
                comp += 1;
                vector<int> noduri;
                pair<int, int> a;
                do {
                    a = muchii.back();
                    muchii.pop_back();
                    noduri.push_back(a.first);
                    noduri.push_back(a.second);
                } while (!(a.first == node && a.second == elem));

                sort(noduri.begin(), noduri.end());
                noduri.erase(unique(noduri.begin(), noduri.end()), noduri.end());

                componente.push_back(noduri);
            }
        }
    }
}

void biconexe()
{
    ifstream fin("biconex.in");
    ofstream fout("biconex.out");

    int n, m;

    fin >> n >> m;

    vector<int> L[n + 1];
    vector<int> niv(n + 1, 0);
    vector<int> low(n + 1, 0);
    vector<pair<int, int>> muchii;
    int comp_bi = 0;

    for(int i = 1; i <= m; i ++)
    {
        int x, y;
        fin >> x >> y;

        L[x].push_back(y);
        L[y].push_back(x);
    }

    for(int i = 1; i <= n; i ++)
    {
        if(niv[i] == 0)
        {
            root = i;
            nr_fii = 0;

            dfs6(i, 0, L, muchii, niv, low, comp_bi);
        }
    }

    fout << comp_bi << '\n';
    for (int i = 0; i < componente.size(); i++)
    {
        for (auto v : componente[i])
            fout << v << ' ';
        fout << '\n';
    }
}

int main()
{
    biconexe();
    return 0;
}