from asyncore import read

#Algoritmul lui Kosaraju
#Complexitate: O(n + m), unde n este numarul de noduri, iar m numarul de muchii

graph = [[] for _ in range (100001)]                #lista de adiacenta a grafului initial
transpose_graph = [[] for _ in range (100001)]      #graful transpus

first_visited = [False for _ in range (100001)]     #nodurile care au fost vizitate in primul dfs
second_visited = [False for _ in range (100001)]    #nodurile care au fost vizitate in cel de-al doilea dfs
stack = []                                          #ordinea nodurilor in parcurgerea BFS pentru graful initial

result = []                                         #vectorul care tine minte nodurile din componente tare conexe
result_index = 0                                    #cate componente conexe sunt

with open("ctc.in", "r") as reader:         
    noduri, muchii = reader.readline().strip().split()
    noduri = int(noduri)                                #citim numarul de noduri
    muchii = int(muchii)                                #si numarul de muchii

    for _ in range (muchii):
        left, right = reader.readline().strip().split()     
        graph[int(left)].append(int(right))                 #alcatuim lista de adiacenta pentru graful initial
        transpose_graph[int(right)].append(int(left))       #si pentru graful transpus


def dfs_order(current_node):
    first_visited[current_node] = True                  #parcurgem cu dfs graful inital
    for vecin in graph [current_node]:
        if first_visited[vecin] == False:
            dfs_order(vecin)
    stack.append(current_node)                          #si salvam ordinea in stiva


def dfs(current_node):                                  #dfs-ul pentru graful transpus
    second_visited[current_node] = True
    result[result_index].append(current_node)           #salvam in matricea result pe o linie
                                                        #componenta tare conexa pe care o parcurgem
    for vecin in transpose_graph[current_node]:
        if second_visited[vecin] == False:
            dfs(vecin)


for node in range (1, noduri + 1):                      #parcurgem cu dfs graful initial
    if first_visited[node] == False:                    #pentru a salva in stiva
        dfs_order(node)

while len(stack) != 0:                                  #luam elementele din stiva
    node = stack.pop()                                  #si parcurgem cu dfs graful transpus
    if second_visited[node] == False:                   #(pornind de la elementele din stiva)
        result.append([])
        dfs(node)
        result_index += 1

with open ("ctc.out", "w") as writer:
    writer.write(str(result_index) + "\n")                          #afisam componentele
    for i in range(result_index):                                   #tare conexe
        for to_print in result[i]:
            writer.write(str(to_print) + " ")
        writer.write("\n")