from collections import defaultdict

count = 0
result = []

class Graph:
    def __init__(self, nodes):
        self.nodes = 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.nodes -= 1
        return self


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

            t = Graph(self.nodes)
            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 SCC(self):
        global count
        if self.nodes > 0:
            transpose_g = self.transpose()

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

            source = list(self.neighbours.keys())[0]

            r1 = self.dfs(source, visited_g)
            r2 = transpose_g.dfs(source, visited_tg)

            res = []

            for i in list(self.neighbours.keys()):
                if r1[i] and r2[i]:
                    res.append(i)

            result.append(res)
            count += 1

            new_g = self.deleteNodes(*res)
            if new_g is not None:
                new_g.SCC()
        else:
            return count


    def bfs(self, s):
        visited = [False] * (max(self.neighbours) + 1)

        queue = []
        cost = [0 for _ in range(max(self.neighbours) + 1)]

        queue.append(s)
        visited[s] = True

        while queue:
            s = queue.pop(0)
            print(s, sep=' ')
            for i in self.neighbours[s]:
                if not visited[i]:
                    queue.append(i)
                    cost[i] = cost[s] + 1
                    visited[i] = True

        for node in self.neighbours.keys():
            if not visited[node]:
                cost[node] = -1

        return cost


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])


num_of_SCC = g.SCC()

print(count)
print(result)

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