output_description: Print 1+K lines, where K is the number of strongly connected components. Print
  K on the first line. Print the information of each strongly connected
  component in next K lines in the following format, where l is the number of
  vertices in the strongly connected component and v_i is the index of the
  vertex in it.
  
      
      
      l v_0 v_1 ... v_{l-1}
      
  
  Here, for each edge (a_i, b_i), b_i should not appear in **earlier** line than
  a_i.
  
  If there are multiple correct output, print any of them.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      a_0 b_0
      a_1 b_1
      :
      a_{M - 1} b_{M - 1}
attempt: import sys
  
  input = sys.stdin.readline
  
  
  def I():
      return int(input())
  
  
  def MI():
      return map(int, input().split())
  
  
  def LI():
      return list(map(int, input().split()))
  
  
  def main():
      def scc(Edge):
          N = len(Edge)
          Edgeinv = [[] for _ in range(N)]
          for vn in range(N):
              for vf in Edge[vn]:
                  Edgeinv[vf].append(vn)
  
          used = [False] * N
          dim = [len(Edge[i]) for i in range(N)]
          order = []
          for st in range(N):
              if not used[st]:
                  stack = [st, 0]
                  while stack:
                      vn, i = stack[-2], stack[-1]
                      if not i and used[vn]:
                          stack.pop()
                          stack.pop()
                      else:
                          used[vn] = True
                          if i < dim[vn]:
                              stack[-1] += 1
                              stack.append(Edge[vn][i])
                              stack.append(0)
                          else:
                              stack.pop()
                              order.append(stack.pop())
          res = [None] * N
          used = [False] * N
          cnt = -1
          for st in order[::-1]:
              if not used[st]:
                  cnt += 1
                  stack = [st]
                  res[st] = cnt
                  used[st] = True
                  while stack:
                      vn = stack.pop()
                      for vf in Edgeinv[vn]:
                          if not used[vf]:
                              used[vf] = True
                              res[vf] = cnt
                              stack.append(vf)
          M = cnt + 1
          components = [[] for _ in range(M)]
          for i in range(N):
              components[res[i]].append(i)
  
          return res, components
  
      N, M = MI()
      adj = [[] for _ in range(N)]
      for i in range(M):
          a, b = MI()
          adj[a].append(b)
  
      res, compo = scc(adj)
  
      M = max(res) + 1
  
      print(M)
      for i in range(M):
          length = len(compo[i])
          print(" ".join(map(str, [length] + compo[i])))
  
  
  main()
  
problem_description: Statement
  
  You are given a directed graph with N vertices and M edges, not necessarily
  simple. The i-th edge is oriented from the vertex a_i to the vertex b_i.
  Divide this graph into strongly connected components and print them in their
  topological order.
samples: [{"input": "6 7\n    1 4\n    5 2\n    3 0\n    5 5\n    4 1\n    0 3\n    4 2", "output": "4\n    1 5\n    2 4 1\n    1 2\n    2 3 0"}]