from collections import defaultdict
from collections import deque
# Kosaraju : DFS graph, save nodes on stack, DFS transpose graph
# sc1-->sc2-->sc3
# sc1<--sc2<--sc3

count = 0
result = []
components = defaultdict(list)
stack = deque()

class Graph:
    def __init__(self, nodes):
        self.numOfNodes = nodes
        self.neighbours = defaultdict(list)


    def addDirectedEdge(self, u, v):
        self.neighbours[u].append(v)


    def addUndirectedEdge(self, u, v):
        self.neighbours[u].append(v)
        self.neighbours[v].append(u)


    def addTransposeEdge(self, u, v):
        self.neighbours[v].append(u)


    def deleteNodes(self, *nodes):
        for node in nodes:
            del self.neighbours[node]
            self.numOfNodes -= 1
        return self


    def transpose(self):
        if self.numOfNodes > 0:
            transposed_graph = defaultdict(list)
            for source, targets in self.neighbours.items():
                for target in targets:
                    transposed_graph[target].append(source)

            t = Graph(self.numOfNodes)
            t.neighbours = transposed_graph

            return t
        else:
            return None


    # def dfs(self, node, visited):
    #     visited[node] = True
    #
    #     for i in self.neighbours[node]:
    #         if not visited[i]:
    #             self.dfs(i, visited)
    #     return visited



    def dfs_Kosaraju1(self, source):
        global stack

        visited[source] = True

        for node in self.neighbours[source]:
            if not visited[node]:
                self.dfs_Kosaraju1(node)
        stack.append(source)


    def dfs_Kosaraju2(self, source):
        global components

        visited[source] = True
        components[count].append(source)

        transpose_g = self.transpose()

        for node in transpose_g.neighbours[source]:
            if not visited[node]:
                self.dfs_Kosaraju2(node)


    def SCC_Kosaraju(self):
        global stack, visited, visited, count

        for node in list(self.neighbours.keys()):
            if not visited[node]:
                g.dfs_Kosaraju1(node)

        visited = {i: False for i in list(self.neighbours.keys())}

        while stack:
            node = stack.pop()
            if not visited[node]:
                count += 1
                g.dfs_Kosaraju2(node)

        return components

file = 'ctc.in'

with open(file, 'rt') as f:
    content = f.readlines()
    content = [line.strip().split() for line in content]
    content = [[int(x) for x in line] for line in content]
    N, M = content[0][0], content[0][1]


g = Graph(N)
for edges in content[1:]:
    g.addDirectedEdge(edges[0], edges[1])

visited = {i: False for i in list(g.neighbours.keys())}

result = g.SCC_Kosaraju()

# print(count)
# print(result)

with open('ctc.out', 'wt') as f:
    f.write(str(count))
    f.write('\n')
    for component in result.values():
        for node in component:
            f.write(str(node))
            f.write(' ')
        f.write('\n')