#pragma GCC optimize("fast-math")

#include <bits/stdc++.h>
#if __has_include("dbg.h")
#  include "dbg.h"
#else
#  define dbg(...) do {} while (0)
#endif

#define cp_lib_4th(_1, _2, _3, x, ...)  x
#define cp_lib_rep(i, l, r)             for (int i = (l); (i) < (r); ++(i))
#define cp_lib_rep0(i, r)               cp_lib_rep(i, 0, r)
#define rep(...)                        cp_lib_4th(__VA_ARGS__, cp_lib_rep, cp_lib_rep0, _)(__VA_ARGS__)
#define cp_lib_repr(i, r, l, ...)       for (int i = (r); (i) >= (l); --(i))
#define repr(...)                       cp_lib_repr(__VA_ARGS__, 0)
#define all(a)                          ::begin(a),::end(a)
#define trav(a, b)                      for (auto&& a : (b))

using namespace std;
using ll = long long;
using ld = long double;
[[maybe_unused]] static constexpr int INF = int(1e9 + 5);
[[maybe_unused]] static constexpr ll INFL = ll(INF) * INF;
template <class C> int sz(const C& c) { return int(::size(c)); }



#if __cpp_lib_remove_cvref < 201711L
template <class T> using remove_cvref_t = remove_cv_t<remove_reference_t<T>>;
#endif
#if __cplusplus < 202002L
struct identity { template <class T> constexpr T&& operator()(T&& t) const noexcept { return forward<T>(t); }; };
template <class T> using iter_value_t = typename iterator_traits<remove_cvref_t<T>>::value_type;
#endif

namespace cp_lib_type_meta {
    template <class T, class = void> constexpr bool is_tuple_like = false;
    template <class T> constexpr bool is_tuple_like<T, void_t<tuple_element_t<0, T>>> = true;
}


namespace cp_lib_modint { struct ModIntTag {}; }
template <class T> constexpr bool IsModInt = is_base_of_v<cp_lib_modint::ModIntTag, T>;
#include <unistd.h>

namespace cp_lib_io {
    constexpr int BUF_SIZE = 1 << 20;
    constexpr array<array<char, 4>, 10'000> DIGITS = []{
        array<array<char, 4>, 10'000> digits{};
        for (int i = 3, d = 1; i >= 0; --i, d *= 10)
            rep(j, 10'000)
                digits[j][i] = char('0' + j / d % 10);
        return digits;
    }();
    array<char, BUF_SIZE> ibuf, obuf;
    char *iptr = data(ibuf), *iend = iptr, *optr = data(obuf);

    template <class T> constexpr bool is_std_array = false;
    template <class T, size_t I> constexpr bool is_std_array<array<T, I>> = true;

    void flush() {
        for (auto* p = begin(obuf); p != optr; p += write(STDOUT_FILENO, p, optr - p));
        optr = begin(obuf);
    }
    int _flush_atexit = []{ atexit(flush); return 0; }();

    void refill() {
        memmove(begin(ibuf), iptr, iend - iptr);
        iend -= iptr - begin(ibuf);
        iptr = begin(ibuf);
        iend += read(STDIN_FILENO, iend, end(ibuf) - 1 - iend);
        *iend = '\0';
    }

    template <class T, class T2 = remove_cvref_t<T>>
    void print(T&& val) {
        if (end(obuf) - optr < 64)
            flush();

        if constexpr (is_same_v<T2, char>)
            *optr++ = val;
        else if constexpr (is_same_v<T2, bool> || is_same_v<T2, vector<bool>::reference>)
            return print(int(val));
        else if constexpr (is_integral_v<T2> && is_signed_v<T2>) {
            if (val < 0)
                *optr++ = '-';
            using U = make_unsigned_t<T2>;
            return print(U(val < 0 ? -U(val) : U(val)));
        } else if constexpr (is_integral_v<T2> && is_unsigned_v<T2>) {
            T2 val2 = val;
            array<char, 64> tmp;
            char* tptr = end(tmp);
            while (val2 >= 10'000)
                tptr -= 4, memcpy(tptr, &DIGITS[val2 % 10'000][0], 4), val2 /= T2(10'000);
            int d = (val2 >= 100 ? (val2 >= 1000 ? 4 : 3) : (val2 >= 10 ? 2 : 1));
            memcpy(optr, &DIGITS[val2][4 - d], d);
            memcpy(optr + d, tptr, end(tmp) - tptr);
            optr += d + int(end(tmp) - tptr);
        } else if constexpr (is_floating_point_v<T2>)
            optr += sprintf(optr, "%.30Lf", (long double)val);
        else if constexpr (is_convertible_v<T, string_view>) {
            string_view sv(val);
            if (sz(sv) + 1 <= end(obuf) - optr)
                memcpy(optr, data(sv), sz(sv)), optr += sz(sv);
            else {
                flush();
                for (auto *p = data(sv), *pe = p + sz(sv); p != pe; p += write(STDOUT_FILENO, p, pe - p));
            }
        } else if constexpr (IsModInt<T2>)
            return print(typename T2::Int(val));
        else if constexpr (cp_lib_type_meta::is_tuple_like<T2> && !is_std_array<T2>)
            return apply([](auto&&... items) { (print(items), ...); }, forward<T>(val));
        else {
            trav(item, val)
                print(item);
            return;
        }
        *optr++ = ' ';
    }

    template <class T>
    void read(T& val) {
        auto skip_ws = [] {
            do {
                for (; iptr != iend && *iptr <= ' '; ++iptr);
                if (iend - iptr < 64)
                    refill();
            } while (*iptr <= ' ');
        };
        auto read_other = [&](auto other) {
            read(other);
            return other;
        };

        if constexpr (is_same_v<T, char>)
            skip_ws(), val = *iptr++;
        else if constexpr (is_same_v<T, bool> || is_same_v<T, vector<bool>::reference>) {
            val = bool(read_other(uint8_t()));
        } else if constexpr (IsModInt<T>) {
            val = T(read_other(ll()));
        } else if constexpr (is_integral_v<T>) {
            skip_ws();
            if (is_signed_v<T> && *iptr == '-')
                ++iptr, val = T(-read_other(make_unsigned_t<T>()));
            else
                for (val = 0; iptr != iend && *iptr > ' '; val = T(10 * val + (*iptr++ & 15)));
        } else if constexpr (is_floating_point_v<T>)
            skip_ws(), val = T(strtold(iptr, &iptr));
        else if constexpr (is_same_v<T, string>) {
            skip_ws();
            val.clear();
            do {
                auto* after = find_if(iptr, iend, [](char c) { return c <= ' '; });
                val.append(iptr, after);
                if ((iptr = after) != iend)
                    break;
                refill();
            } while (iptr != iend);
        } else if constexpr (cp_lib_type_meta::is_tuple_like<T> && !is_std_array<T>)
            apply([](auto&... items) { (read(items), ...); }, val);
        else
            trav(item, val)
                read(item);
    }
}

using cp_lib_io::flush;

template <class... Args>
void print(Args&&... args) { (cp_lib_io::print(forward<Args>(args)), ...); }

template <class... Args>
void println(Args&&... args) {
    if (sizeof...(Args))
        (cp_lib_io::print(forward<Args>(args)), ...), *(cp_lib_io::optr - 1) = '\n';
    else
        print('\n'), --cp_lib_io::optr;
}

template <class... Args>
void read(Args&... args) { (cp_lib_io::read(args), ...); }

namespace cp_lib_span {
    template <class P> constexpr auto to_address(const P& p) noexcept { return p.operator->(); }
    template <class T> constexpr T* to_address(T* p) noexcept { return p; }
}

template <class T>
class MiniSpan {
    T *begin_ = nullptr, *end_ = nullptr;

 public:
    constexpr MiniSpan() noexcept;
    template <class It>
    constexpr MiniSpan(It first, size_t count) : begin_(cp_lib_span::to_address(first)), end_(begin_ + count) {}
    template <class It, class End>
    constexpr MiniSpan(It first, End last) : MiniSpan(first, size_t(last - first)) {}

    constexpr MiniSpan& operator=(const MiniSpan&) noexcept = default;

    constexpr auto begin() const noexcept { return begin_; }
    constexpr auto end() const noexcept { return end_; }
    constexpr auto rbegin() const noexcept { return make_reverse_iterator(end_); }
    constexpr auto rend() const noexcept { return make_reverse_iterator(begin_); }
    constexpr size_t size() const noexcept { return end_ - begin_; }
    constexpr const T& operator[](size_t i) const { return *(begin_ + i); }
};

template <class It, class EndOrSize>
MiniSpan(It, EndOrSize) -> MiniSpan<remove_reference_t<decltype(*declval<It&>())>>;

template <bool EdgeId> struct MaybeEdgeId {
    int id_or_zero() const noexcept { return 0; }
};
template <> struct MaybeEdgeId<true> {
    int id;
    int id_or_zero() const noexcept { return id; }
};

template <class Cost> struct MaybeCost { Cost cost; };
template <> struct MaybeCost<void> {};

template <bool EdgeId, class Cost>
struct Edge : MaybeEdgeId<EdgeId>, MaybeCost<Cost> { int to; };

struct GraphOptions {
    static constexpr int DIRECTED = 1, EDGE_IDS = 2;
};

template <int Options = 0, class Cost_ = void>
struct Graph {
    static constexpr bool Directed = Options & GraphOptions::DIRECTED;
    static constexpr bool HasEdgeIds = Options & GraphOptions::EDGE_IDS;
    static constexpr bool HasCosts = !is_void_v<Cost_>;
    using Cost = Cost_;
    using Edge = ::Edge<HasEdgeIds, Cost>;
    using EdgeIt = decltype(begin(declval<MiniSpan<Edge>>()));
    using ConstEdgeIt = decltype(begin(declval<MiniSpan<const Edge>>()));

    vector<Edge> edges;
    vector<int> idx;

    template <class BuildEdges>
    explicit Graph(int n, int m_hint, BuildEdges&& build_edges) : idx(n + 1) {
        vector<pair<int, Edge>> edge_list;
        edge_list.reserve(m_hint);

        auto add_edge = [&](int from, int to) -> Edge& {
            auto& edge = edge_list.emplace_back(from, Edge{}).second;
            idx[from + 1]++;
            idx[to + 1] += !Directed;
            edge.to = to;
            return edge;
        };
        if constexpr (HasCosts)
            build_edges([&](int from, int to, Cost cost) { add_edge(from, to).cost = cost; });
        else
            build_edges(add_edge);

        exclusive_scan(all(idx), begin(idx), 0);
        edges.resize(sz(edge_list) << int(!Directed));
        rep(i, sz(edge_list)) {
            auto [from, edge] = move(edge_list[i]);
            if constexpr (HasEdgeIds)
                edge.id = i;
            if constexpr (!Directed)
                (edges[idx[edge.to + 1]++] = edge).to = from;
            edges[idx[from + 1]++] = move(edge);
        }
    }

    template <class Read>
    static Graph read_graph(int n, int m, int v0, Read&& read) {
        return Graph(n, m, [&](auto&& add_edge) {
            rep(_, m) {
                int from, to;
                read(from);
                read(to);
                if constexpr (HasCosts) {
                    Cost cost;
                    read(cost);
                    add_edge(from - v0, to - v0, move(cost));
                } else
                    add_edge(from - v0, to - v0);
            }
        });
    }

    template <class Read>
    static Graph read_tree(int n, int v0, Read&& read) {
        return read_graph(n, n - 1, v0, forward<Read>(read));
    }

    template <class Read, bool C = HasCosts, enable_if_t<!C, int> = 0>
    static Graph read_parent_tree(int n, int v0, Read&& read) {
        return Graph(n, n - 1, [&](auto&& add_edge) {
            int p;
            rep(i, 1, n)
                read(p), add_edge(p - v0, i);
        });
    }

    MiniSpan<Edge> operator[](int v) noexcept { return MiniSpan(begin(edges) + idx[v], begin(edges) + idx[v + 1]); }
    MiniSpan<const Edge> operator[](int v) const noexcept { return MiniSpan(begin(edges) + idx[v], begin(edges) + idx[v + 1]); }

    int n() const noexcept { return sz(idx) - 1; }
    int m() const noexcept { return sz(edges) >> int(!Directed); }
};

template <class Graph>
auto find_cycle(const Graph& graph) {
    vector<typename Graph::EdgeIt> edges;
    vector<uint8_t> state(graph.n());
    auto dfs = [&](auto&& self, int v, auto inc) -> bool {
        state[v] = 1;
        for (auto it = begin(graph[v]), it_end = end(graph[v]); it != it_end; ++it) {
            if (int v2 = it->to, e = it->id_or_zero(); state[v2] != 2 && (Graph::Directed || pair(v2, e) != inc)) {
                edges.push_back(it);
                if (state[v2] == 1 || self(self, v2, pair(v, e)))
                    return true;
                edges.pop_back();
            }
        }
        state[v] = 2;
        return false;
    };

    rep(v0, graph.n()) {
        if (!state[v0] && dfs(dfs, v0, pair(-1, -1))) {
            auto it = begin(edges);
            for (int vn = edges.back()->to; v0 != vn;)
                v0 = (*it++)->to;
            edges.erase(begin(edges), it);
            break;
        }
    }

    return edges;
}

template <class Graph, class OnComp>
void strongly_connected_components(const Graph& graph, OnComp&& on_comp) {
    int n = graph.n();
    vector<int> val(n), stack;
    stack.reserve(n);
    auto dfs = [&, on_comp = forward<OnComp>(on_comp)](auto&& self, int v) -> int {
        stack.push_back(v);
        int low = val[v] = sz(stack);
        trav(e, graph[v])
            if (val[e.to] != -1)
                low = min(low, val[e.to] ? val[e.to] : self(self, e.to));

        if (val[v] != low)
            return val[v] = low;

        auto it = prev(end(stack));
        for (val[v] = -1; *it != v; val[*it--] = -1);
        on_comp(MiniSpan(it, end(stack)));
        stack.erase(it, end(stack));
        return low;
    };

    rep(v, n)
        if (!val[v])
            dfs(dfs, v);
}

int main() {
    int n, m; read(n, m);
    auto graph = Graph<GraphOptions::DIRECTED>::read_graph(n, m, 0, [](auto& x) { read(x); });

    vector nodes(n, 0), idx = {n};
    strongly_connected_components(graph, [&](const auto& comp) {
        copy(all(comp), make_reverse_iterator(begin(nodes) + idx.back()));
        idx.push_back(idx.back() - sz(comp));
    });

    println(sz(idx) - 1);
    repr(i, sz(idx) - 2) {
        MiniSpan comp(begin(nodes) + idx[i + 1], begin(nodes) + idx[i]);
        println(sz(comp), comp);
    }
}