class SCCGraph
    def initialize(n = 0)
      @n, @edges = n, []
    end
  
    def add_edge(from, to); @edges << [from, to]; end
  
    # returns list of strongly connected components
    # the components are sorted in topological order
    # O(N + M)
    def scc
        group_num, ids = scc_ids
        counts = Array.new(group_num, 0)
        ids.each { |x| counts[x] += 1 }
        groups = Array.new(group_num) { [] }
        ids.each_with_index { |x, i| groups[x] << i }
        groups
    end

    def scc_ids
        start, elist = csr
        now_ord = group_num = 0
        visited, low, ord, ids = [], [], [-1] * @n, []
        dfs = ->(v) {
        low[v] = ord[v] = now_ord
        now_ord += 1
        visited << v
        (start[v]...start[v + 1]).each do |i|
            to = elist[i]
            low[v] = if ord[to] == -1
                        dfs.(to)
                        [low[v], low[to]].min
                    else
                        [low[v], ord[to]].min
                    end
        end
        if low[v] == ord[v]
            loop do
            u = visited.pop
            ord[u] = @n
            ids[u] = group_num
            break if u == v
            end
            group_num += 1
        end
        }
        @n.times { |i| dfs.(i) if ord[i] == -1 }
        ids = ids.map { |x| group_num - 1 - x }
        [group_num, ids]
    end
  
    def csr
        start = Array.new(@n+1, 0)
        elist = Array.new(@edges.size)
        @edges.each { |(i, _)| start[i + 1] += 1 }
        @n.times { |i| start[i + 1] += start[i] }
        counter = start.dup
        @edges.each do |(i, j)|
            elist[counter[i]] = j
            counter[i] += 1
        end
        [start, elist]
    end
end

n, m = gets.split.map(&:to_i)
scc = SCCGraph.new(n)

m.times {scc.add_edge(*gets.split.map(&:to_i))}
ans = scc.scc
puts ans.size
ans.each{|e| puts "#{e.size} " + e*" "}