#include <fstream>
#include <vector>
#include <stack>
#include <algorithm>
using namespace std;

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

int n, m;
vector<vector<int>> G; //graful
vector<bool> p;        //p[i] == true => i punct de articulatie
vector<int> t;         //sir de tati
vector<int> niv;       //nivelul fiecarui nod in arborele DFS
vector<int> L;         //nivelul minim
vector<bool> s;
int root;              //nodul ales radacina
int nr;                //nr de muchii de arbore(care ies din radacina)

vector<vector<int>> C;
vector<int> c;
stack<pair<int, int>> S;
int x1, x2;

void Read();
void DFS(int x, int nv);
void PuncteArticulatie();
void Write();

int main() {
    Read();
    root = 1;
    DFS(root, 1);
    //PuncteArticulatie();
    Write();
    fin.close();
    fout.close();
    return 0;
}

void PuncteArticulatie() {
    if (nr > 1) p[root] = true;
    for (int i = 1; i <= n; i++) {
        if (i == root || t[i] == root) continue;
        if (L[i] >= niv[t[i]]) p[t[i]] = true;
    }
}

void DFS(int x, int nv) {
    if (nv == 2) nr++;
    L[x] = niv[x] = nv;
    s[x] = true;
    for (const int& y : G[x]) {
        if (y == t[x]) continue;
        if (!s[y]) {
            t[y] = x;
            S.push({x, y});
            DFS(y, nv + 1);
            L[x] = min(L[x], L[y]);
            if (L[y] >= niv[x]) {
                c.clear();
                while(true) {
                    x1 = S.top().first;
                    x2 = S.top().second;
                    S.pop();
                    c.push_back(x1);
                    c.push_back(x2);
                    if (x1 == x && x2 == y) break;
                }
                C.push_back(c);
            }
        }
        else
            L[x] = min(L[x], niv[y]);
    }
}

void Read() {
    fin >> n >> m;
    G = vector<vector<int>>(n + 1);
    p = s = vector<bool>(n + 1);
    t = niv = L = vector<int>(n + 1);
    for (int i = 1, x, y; i <= m; i++) {
        fin >> x >> y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
}

void Write() {
    fout << C.size() << '\n';
    for (auto& c : C) {
        sort(c.begin(), c.end());
        c.erase(unique(c.begin(), c.end()), c.end());
        for (const auto& x : c)
            fout << x << ' ';
        fout << '\n';
    }
}