#include <fstream>
#include <vector>
#include <stack>
#include <algorithm>

#define MAX 100005

using namespace std;

vector<int> lowest, dist;
stack<pair<int, int> > edges;
vector<int> graph[MAX];
vector<vector<int> > sol;

void read()
{
    ifstream f("biconex.in");
    int i, j;
    
    f >> i >> j;
    lowest.resize(i + 1);
    dist.resize(i + 1, -1);
    while (f >> i && f >> j)
    {
        graph[i].push_back(j);
        graph[j].push_back(i);
    }
    f.close();
}

void DFS(int node, int parent)
{
    lowest[node] = dist[node] = dist[parent] + 1;
    for (vector<int>::iterator i = graph[node].begin(); i != graph[node].end(); ++i)
    {
        if (*i == parent) continue;
        
        if (dist[*i] == -1)
        {
            edges.push(make_pair(node, *i));
            DFS(*i, node);
            lowest[node] = min(lowest[node], lowest[*i]);
            if (lowest[*i] >= dist[node])
            {
                vector<int> solVector;
                int x, y;
                
                do
                {
                    x = edges.top().first;
                    y = edges.top().second;
                    edges.pop();
                    solVector.push_back(x);
                    solVector.push_back(y);
                } while (x != node && y != *i);
                
                sort(solVector.begin(), solVector.end());
                solVector.erase(unique(solVector.begin(), solVector.end()), solVector.end());
                sol.push_back(solVector);
            }
        }
        else
            lowest[node] = min(lowest[node], lowest[*i]);
    }
}

void write()
{
    ofstream f("biconex.out");
    
    f << sol.size() << "\n";
    for (vector<vector<int> >::iterator i = sol.begin(); i != sol.end(); ++i)
    {
        for (vector<int>::iterator j = i->begin(); j != i->end(); ++j)
            f << *j << " ";
        f << "\n";
    }
    
    f.close();
}

int main()
{
    read();
    DFS(1, 0);
    write();
    
    return 0;
}