/*
Catalin-Stefan Tiseanu
Pre-written code is assembled from various sources found online.
Big thanks to the community for that !
*/
// Pre-written code below
using namespace std;
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <unordered_map>
#include <unordered_set>
//START_CLEAN
// always remove
//START:mandatory
//#define DEBUG
#ifndef NDEBUG
# define assert_msg(condition, message) \
do { \
if (! (condition)) { \
std::cerr << "Assertion `" #condition "` failed in " << __FILE__ \
<< " line " << __LINE__ << ": " << message << std::endl; \
std::exit(EXIT_FAILURE); \
} \
} while (false)
#else
# define ASSERT(condition, message) do { } while (false)
#endif
#ifdef DEBUG
#define debug(args...) {dbg,args; cerr<<endl;}
#else
#define debug(args...) // Just strip off all debug tokens
#endif
template<class T> std::ostream& operator <<(std::ostream& stream, const vector<T> & v) {
for (auto el : v)
stream << el << " ";
return stream;
}
template<class T> std::ostream& operator <<(std::ostream& stream, const vector<vector<T>> & v) {
for (auto line : v) {
for (auto el : line)
stream << el << " ";
stream << endl;
}
return stream;
}
template<class T, class U> std::ostream& operator <<(std::ostream& stream, const pair<U, T> & p) {
stream << "( " << p.first << ", " << p.second << " )";
return stream;
}
class debugger {
public:
template<class T> void output (const T& v) {
cerr << v << " ";
}
template<class T> debugger& operator , (const T& v) {
output(v);
return *this;
}
} dbg;
//END:mandatory
////////////////
// templates //
////////////////
// general
//template size
template<typename T> int size(const T& c) { return int(c.size()); }
//template abs
template<typename T> T abs(T x) { return x < 0 ? -x : x; }
//template sqr
template<typename T> T sqr(T x) { return x*x; }
//template remin
template<typename T> bool remin(T& x, T y) { if (x <= y) return false; x = y; return true; }
//template remax
template<typename T> bool remax(T& x, T y) { if (x >= y) return false; x = y; return true; }
//template factorize
template<class T> inline vector<pair<T,int> > factorize(T n) {vector<pair<T,int> > R;for (T i=2;n>1;){if (n%i==0){int C=0;for (;n%i==0;C++,n/=i);R.push_back(make_pair(i,C));} i++;if (i>n/i) i=n;}if (n>1) R.push_back(make_pair(n,1));return R;}
//template toStr
template<typename T> string toStr(T x) { stringstream ss; ss << x; return ss.str(); }
// other
string maskToStr(long long x, int len) {stringstream ss; for (int i = 0; i < len; ++i) if (x >> i & 1) ss << "1"; else ss << "0"; return ss.str();}
// misc
#define EPS 1e-5
// types
//template int64
typedef long long int64 ;
//template uint64
typedef unsigned long long uint64 ;
// shortcuts
#define all(_xx) _xx.begin(), _xx.end()
#define pb push_back
#define vi vector<int>
#define vs vector<string>
#define vvi vector<vector<int>>
#define vd vector<double>
#define vpii vector<pair<int,int> >
#define vpdd vector<pair<double,double> >
#define pii pair<int,int>
#define pll pair<long long, long long>
#define pdd pair<double, double>
#define mp(XX, YY) make_pair(XX, YY)
#define fi first
#define se second
#define ll long long
#define SS stringstream
// for loops
#define re(II, NN) for (int II(0), _NN(NN); (II) < (NN); ++(II))
#define fod(II, XX, YY) for (int II(XX), _YY(YY); (II) >= (_YY); --(II))
#define fo(II, XX, YY) for (int II(XX), _YY(YY); (II) <= (_YY); ++(II))
#define foreach(it,c) for(__typeof((c).begin()) it=(c).begin();it!=(c).end();++it)
// Useful hardware instructions
#define bitcount __builtin_popcount
#define gcd __gcd
// Useful all around
#define checkbit(n,b) ( (n >> b) & 1)
#define DREP(a) sort(a.begin(), a.end());a.erase(unique(a.begin(), a.end()),a.end())
#define INDEX(arr,ind) (lower_bound(arr.begin(), arr.end(),ind)-arr.begin())
#define PAUSE cerr << "Press any key to continue ..."; char xxxx; scanf("%c", &xxxx);
#define fill(xx,val) memset(xx, val, sizeof(xx))
struct Scanner {
char* curPos;
const static int BUF_SIZE = (2000000);
char input[BUF_SIZE];
FILE * fin;
void init(FILE * _fin) {
fin = _fin;
fread(input, 1, sizeof(input), fin);
curPos = input;
}
Scanner() {;}
inline void ensureCapacity() {
int size = input + BUF_SIZE - curPos;
if (size < 100) {
memcpy(input, curPos, size);
fread(input + size, 1, BUF_SIZE - size, fin);
curPos = input;
}
}
inline int nextInt() {
ensureCapacity();
while (!isdigit(*curPos) && *curPos != '-')
++curPos;
int res = 0;
int sign = 1;
if (*curPos == '-')
sign = -1,
++curPos;
while (*curPos >= '0' && *curPos <= '9')
res = res * 10 + (*(curPos++) & 15);
return sign * res;
}
} Sc;
// code starts here
struct BiconnectedGraph {
// doit by edges
// result[i] = biconnected component of node i (by edges)
int N;
vvi g;
vi depth, parent, low;
vector<bool> visited;
vi comp_edge;
vvi comp_vertex;
struct UnionFind {
vector<int> p;
int gp(int x) {
if (p[x] != x) {
p[x] = gp(p[x]);
}
return p[x];
}
void un(int a, int b) {
p[gp(a)] = gp(b);
}
void init(int n) {
p.reserve(n);
re (i, n) p.pb(i);
}
UnionFind() {;}
UnionFind(int n) {init(n);}
} uf;
void dfs_low(int x) {
visited[x] = true;
low[x] = depth[x];
for (auto it : g[x]) {
if (!visited[it]) {
depth[it] = depth[x] + 1;
parent[it] = x;
dfs_low(it);
low[x] = min(low[x], low[it]);
if (low[it] <= depth[x]) {
uf.un(x, it);
}
} else if (it != parent[x]) {
low[x] = min(low[x], depth[it]);
}
}
}
void getByEdges() {
N = g.size();
uf.init(N);
visited = vector<bool>(N, false);
parent = vi(N, -1);
depth = vi(N, 0);
low = vi(N, -1);
visited.reserve(N);
parent.reserve(N);
depth.reserve(N);
low.reserve(N);
re (i, N)
if (!visited[i])
dfs_low(i);
comp_edge.clear();
comp_edge.reserve(N);
re (i, N) comp_edge.pb(uf.gp(i));
}
void add_to_comp(int x, vi & comp) {
if (visited[x]) return;
visited[x] = true;
comp.pb(x);
for (auto y : g[x])
if (!visited[y] && comp_edge[x] == comp_edge[y])
add_to_comp(y, comp);
}
void getByVertices() {
getByEdges();
re (i, N) visited[i] = false;
comp_vertex.reserve(N);
re (x, N)
for (auto y : g[x]) {
debug(x, y, comp_edge[x], comp_edge[y]);
if (comp_edge[x] != comp_edge[y] && x < y) {
vi cur_comp(2);
cur_comp[0] = x, cur_comp[1] = y;
comp_vertex.pb(cur_comp);
} else if (!visited[x]) {
comp_vertex.pb(vi());
add_to_comp(x, comp_vertex.back());
if (comp_vertex.back().size() == 1)
comp_vertex.pop_back();
}
}
}
void init(int N) {
g.clear();
g.resize(N);
g.reserve(N);
}
inline void add_edge(int x, int y) {
g[x].pb(y);
}
} G;
int main() {
freopen("biconex.in", "r", stdin);
freopen("biconex.out", "w", stdout);
int N, M;
Sc.init(stdin);
N = Sc.nextInt(), M = Sc.nextInt();
G.init(N);
fo (i, 1, M) {
int x = Sc.nextInt(), y = Sc.nextInt();
--x, --y;
G.add_edge(x, y);
G.add_edge(y, x);
}
G.getByVertices();
printf("%d\n", G.comp_vertex.size());
re (i, G.comp_vertex.size()) {
printf("%d", G.comp_vertex[i][0] + 1);
fo (j, 1, G.comp_vertex[i].size() - 1)
printf(" %d", G.comp_vertex[i][j] + 1);
printf("\n");
}
return 0;
}