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 os
  import sys
  
  import numpy as np
  
  
  def solve(inp):
      def dfs(links, s, checked, postorder):
          n = len(links)
          d = 1
          while d <= n:
              d <<= 1
  
          q = [s]
          checked[s] = 1
          while q:
              v = q.pop()
              if v < d:
                  q.append(v | d)
                  for u in links[v]:
                      if checked[u] == 0:
                          q.append(u)
                          checked[u] = 1
              else:
                  postorder.append(v ^ d)
          return
  
      def dfs2(rev_links, s, checked):
          q = [s]
          checked[s] = 1
          scc = [s]
          while q:
              v = q.pop()
              for u in rev_links[v]:
                  if checked[u] == 0:
                      q.append(u)
                      checked[u] = 1
                      scc.append(u)
          return scc
  
      n = inp[0]
      m = inp[1]
      aaa = inp[2::2]
      bbb = inp[3::2]
  
      int_list = [0]
      int_list.clear()
      links = [int_list.copy() for _ in range(n)]
      rev_links = [int_list.copy() for _ in range(n)]
  
      for i in range(m):
          a = aaa[i]
          b = bbb[i]
          if a != b:
              links[a].append(b)
              rev_links[b].append(a)
      links = [list(set(link)) for link in links]
      rev_links = [list(set(link)) for link in rev_links]
  
      checked = np.zeros(n, np.int8)
      postorder = []
  
      for v in range(n):
          if checked[v]:
              continue
          dfs(links, v, checked, postorder)
  
      postorder.reverse()
      checked = np.zeros(n, np.int8)
      sccs = []
  
      for v in postorder:
          if checked[v]:
              continue
          sccs.append(dfs2(rev_links, v, checked))
  
      return sccs
  
  
  if sys.argv[-1] == "ONLINE_JUDGE":
      from numba.pycc import CC
  
      cc = CC("my_module")
      cc.export("solve", "(i8[:],)")(solve)
      cc.compile()
      exit()
  
  if os.name == "posix":
      # noinspection PyUnresolvedReferences
      from my_module import solve
  else:
      from numba import njit
  
      solve = njit("(i8[:],)", cache=True)(solve)
      print("compiled", file=sys.stderr)
  
  inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=" ")
  ans = solve(inp)
  print(len(ans))
  for scc in ans:
      print(len(scc), *scc)
  
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"}]