class Graph(): #directed

    def __init__(self, n, edge, indexed=1):

        self.n = n

        self.graph = [[] for _ in range(n)]

        self.rev = [[] for _ in range(n)]

        self.deg = [0 for _ in range(n)]

        for e in edge:

            self.graph[e[0] - indexed].append(e[1] - indexed)

            self.rev[e[1] - indexed].append(e[0] - indexed)

            self.deg[e[1] - indexed] += 1



    def strongry_connected(self):

        group = [None for _ in range(self.n)]

        used = [0 for _ in range(self.n)]

        order = []

        for s in range(self.n):

            if not used[s]:

                stack = [s]

                used[s] = 1

                while stack:

                    node = stack.pop()

                    movable = False

                    for adj in self.graph[node]:

                        if not used[adj]:

                            movable = True

                            used[adj] = 1

                            stack.append(node)

                            stack.append(adj)

                            break

                    if not movable:

                        order.append(node)

        used = [0 for _ in range(self.n)]

        count = 0

        for s in order[::-1]:

            if not used[s]:

                stack = [s]

                group[s] = count

                while stack:

                    node = stack.pop()

                    used[node] = 1

                    for adj in self.rev[node]:

                        if not used[adj]:

                            group[adj] = count

                            stack.append(adj)

                count += 1

        return group, count



import sys

input = sys.stdin.buffer.readline



N, M = list(map(int, input().split()))

E = [tuple(map(int, input().split())) for _ in range(M)]



g = Graph(N, E, 0)

group, count = g.strongry_connected()



res = [[] for _ in range(count)]



for i, k in enumerate(group):

    res[k].append(i)



print(count)



for r in res:

    print((len(r), *r))
class StronglyConnectedComponents():

    def __init__(self, n):

        self.n = n

        self.graph = [[] for _ in range(n)]

        self.rev = [[] for _ in range(n)]



    def add_edge(self, fr, to):

        self.graph[fr].append(to)

        self.rev[to].append(fr)



    def scc_id(self):

        group = [-1] * self.n

        vis = [0] * self.n

        order = []

        for s in range(self.n):

            if vis[s]: continue

            stack = [s]

            vis[s] = True

            while stack:

                node = stack.pop()

                for adj in self.graph[node]:

                    if vis[adj]: continue

                    vis[adj] = True

                    stack.append(node)

                    stack.append(adj)

                    break

                else:

                    order.append(node)

        cnt = 0

        for s in order[::-1]:

            if group[s] != -1: continue

            stack = [s]

            group[s] = cnt

            while stack:

                node = stack.pop()

                for adj in self.rev[node]:

                    if group[adj] != -1: continue

                    group[adj] = cnt

                    stack.append(adj)

            cnt += 1

        return group, cnt



    def scc(self):

        group, cnt = self.scc_id()

        res = [[] for _ in range(cnt)]

        for i in range(self.n):

            res[group[i]].append(i)

        return res



import sys

input = sys.stdin.buffer.readline



N, M = list(map(int, input().split()))



scc = StronglyConnectedComponents(N)



for _ in range(M):

    a, b = list(map(int, input().split()))

    scc.add_edge(a, b)



res = scc.scc()

print((len(res)))



for r in res:

    print((len(r), *r))
class Graph:  # directed
    def __init__(self, n, edge, indexed=1):
        self.n = n
        self.graph = [[] for _ in range(n)]
        self.rev = [[] for _ in range(n)]
        self.deg = [0 for _ in range(n)]
        for e in edge:
            self.graph[e[0] - indexed].append(e[1] - indexed)
            self.rev[e[1] - indexed].append(e[0] - indexed)
            self.deg[e[1] - indexed] += 1

    def strongry_connected(self):
        group = [None for _ in range(self.n)]
        used = [0 for _ in range(self.n)]
        order = []
        for s in range(self.n):
            if not used[s]:
                stack = [s]
                used[s] = 1
                while stack:
                    node = stack.pop()
                    movable = False
                    for adj in self.graph[node]:
                        if not used[adj]:
                            movable = True
                            used[adj] = 1
                            stack.append(node)
                            stack.append(adj)
                            break
                    if not movable:
                        order.append(node)
        used = [0 for _ in range(self.n)]
        count = 0
        for s in order[::-1]:
            if not used[s]:
                stack = [s]
                group[s] = count
                while stack:
                    node = stack.pop()
                    used[node] = 1
                    for adj in self.rev[node]:
                        if not used[adj]:
                            group[adj] = count
                            stack.append(adj)
                count += 1
        return group, count


import sys

input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
E = [tuple(map(int, input().split())) for _ in range(M)]
g = Graph(N, E, 0)
group, count = g.strongry_connected()
res = [[] for _ in range(count)]
for i, k in enumerate(group):
    res[k].append(i)
print(count)
for r in res:
    print((len(r), *r))

class StronglyConnectedComponents:
    def __init__(self, n):
        self.n = n
        self.graph = [[] for _ in range(n)]
        self.rev = [[] for _ in range(n)]

    def add_edge(self, fr, to):
        self.graph[fr].append(to)
        self.rev[to].append(fr)

    def scc_id(self):
        group = [-1] * self.n
        vis = [0] * self.n
        order = []
        for s in range(self.n):
            if vis[s]:
                continue
            stack = [s]
            vis[s] = True
            while stack:
                node = stack.pop()
                for adj in self.graph[node]:
                    if vis[adj]:
                        continue
                    vis[adj] = True
                    stack.append(node)
                    stack.append(adj)
                    break
                else:
                    order.append(node)
        cnt = 0
        for s in order[::-1]:
            if group[s] != -1:
                continue
            stack = [s]
            group[s] = cnt
            while stack:
                node = stack.pop()
                for adj in self.rev[node]:
                    if group[adj] != -1:
                        continue
                    group[adj] = cnt
                    stack.append(adj)
            cnt += 1
        return group, cnt

    def scc(self):
        group, cnt = self.scc_id()
        res = [[] for _ in range(cnt)]
        for i in range(self.n):
            res[group[i]].append(i)
        return res


import sys

input = sys.stdin.buffer.readline
N, M = list(map(int, input().split()))
scc = StronglyConnectedComponents(N)
for _ in range(M):
    a, b = list(map(int, input().split()))
    scc.add_edge(a, b)
res = scc.scc()
print((len(res)))
for r in res:
    print((len(r), *r))

-class Graph:  # directed -    def __init__(self, n, edge, indexed=1): +class StronglyConnectedComponents: +    def __init__(self, n): -        self.deg = [0 for _ in range(n)] -        for e in edge: -            self.graph[e[0] - indexed].append(e[1] - indexed) -            self.rev[e[1] - indexed].append(e[0] - indexed) -            self.deg[e[1] - indexed] += 1 -    def strongry_connected(self): -        group = [None for _ in range(self.n)] -        used = [0 for _ in range(self.n)] +    def add_edge(self, fr, to): +        self.graph[fr].append(to) +        self.rev[to].append(fr) + +    def scc_id(self): +        group = [-1] * self.n +        vis = [0] * self.n -            if not used[s]: -                stack = [s] -                used[s] = 1 -                while stack: -                    node = stack.pop() -                    movable = False -                    for adj in self.graph[node]: -                        if not used[adj]: -                            movable = True -                            used[adj] = 1 -                            stack.append(node) -                            stack.append(adj) -                            break -                    if not movable: -                        order.append(node) -        used = [0 for _ in range(self.n)] -        count = 0 +            if vis[s]: +                continue +            stack = [s] +            vis[s] = True +            while stack: +                node = stack.pop() +                for adj in self.graph[node]: +                    if vis[adj]: +                        continue +                    vis[adj] = True +                    stack.append(node) +                    stack.append(adj) +                    break +                else: +                    order.append(node) +        cnt = 0 -            if not used[s]: -                stack = [s] -                group[s] = count -                while stack: -                    node = stack.pop() -                    used[node] = 1 -                    for adj in self.rev[node]: -                        if not used[adj]: -                            group[adj] = count -                            stack.append(adj) -                count += 1 -        return group, count +            if group[s] != -1: +                continue +            stack = [s] +            group[s] = cnt +            while stack: +                node = stack.pop() +                for adj in self.rev[node]: +                    if group[adj] != -1: +                        continue +                    group[adj] = cnt +                    stack.append(adj) +            cnt += 1 +        return group, cnt + +    def scc(self): +        group, cnt = self.scc_id() +        res = [[] for _ in range(cnt)] +        for i in range(self.n): +            res[group[i]].append(i) +        return res -E = [tuple(map(int, input().split())) for _ in range(M)] -g = Graph(N, E, 0) -group, count = g.strongry_connected() -res = [[] for _ in range(count)] -for i, k in enumerate(group): -    res[k].append(i) -print(count) +scc = StronglyConnectedComponents(N) +for _ in range(M): +    a, b = list(map(int, input().split())) +    scc.add_edge(a, b) +res = scc.scc() +print((len(res)))