# https://yukicoder.me/problems/no/1553

from collections import deque

def scc(N, next_nodes):
    """
    有向グラフにおける強連結成分分解
    """
    # 深さ優先探索をしてラベリング
    stack = deque()
    labeling = [-1] * N
    v_list = []
    parents = [-2] * N
    v_index = 0
    for s_i in range(N):
        if parents[s_i] == -2:
            parents[s_i] = -1
            stack.append((s_i, 0))
            while len(stack) > 0:
                v, index = stack.pop()
                while index < len(next_nodes[v]):
                    w = next_nodes[v][index]
                    if w == parents[v]:
                        index += 1
                        continue
    
                    if parents[w] != -2:
                        index += 1
                        continue

                    parents[w] = v
                    stack.append((v, index + 1))
                    stack.append((w, 0))
                    break

                if len(next_nodes[v]) == index:
                    labeling[v] = v_index
                    v_list.append(v)
                    v_index + 1
    
    # 逆グラフの生成
    reversed_nodes = [[] for _ in range(N)]
    for i in range(N):
        for w in next_nodes[i]:
            reversed_nodes[w].append(i)

    scc_label = [-1] * N
    scc_index = 0
    for s_v in reversed(v_list):
        if scc_label[s_v] == -1:
            queue = deque()
            queue.append(s_v)
            scc_label[s_v] = scc_index
            while len(queue) > 0:
                v = queue.popleft()
                for w in reversed_nodes[v]:
                    if scc_label[w] == -1:
                        scc_label[w] = scc_index
                        queue.append(w)
            scc_index += 1
    return scc_label


class UnionFind:
    """
    UnionFindの基本的な処理を実装したクラス
    """

    def __init__(self, size):
        self.root = [i for i in range(size)]
        self.size = [1] * size

    def get_root(self, v):
        if v == self.root[v]:
            return v
        else:
            old_root = self.root[v]
            new_root = self.get_root(old_root)
            self.root[v] = new_root
            return new_root

    def merge(self, u, v):
        root_u = self.get_root(u)
        root_v = self.get_root(v)
        if root_u == root_v:
            return False

        if self.size[root_u] >= self.size[root_v]:
            self.size[root_u] += self.size[root_v]
            self.root[root_v] = root_u
            self.root[v] = root_u
        else:
            self.size[root_v] += self.size[root_u]
            self.root[root_u] = root_v
            self.root[u] = root_v
        return True

def main():
    N, M = map(int, input().split())
    next_nodes = [[ ] for _ in range(N)]
    edges = []
    for _ in range(M):
        u, v = map(int, input().split())
        next_nodes[u - 1].append(v - 1)
        edges.append((u - 1, v - 1))

    scc_labels = scc(N, next_nodes)
    scc_num = max(scc_labels) + 1

    # まず連結成分同士で行き来できないといけないのでそれを足す
    scc_map = {}
    for i in range(N):
        scc_i = scc_labels[i]
        if scc_i not in scc_map:
            scc_map[scc_i] = []
        scc_map[scc_i].append(i)
    
    answer = []
    for nodes in scc_map.values():
        if len(nodes) <= 1:
            continue

        for i in range(len(nodes)):
            v = nodes[i]
            w = nodes[(i + 1) % len(nodes)]
            answer.append((v, w))

    # 連結成分ごとに分解
    uf = UnionFind(scc_num)
    for u, v in edges:
        scc_u = scc_labels[u]
        scc_v = scc_labels[v]
        uf.merge(scc_u, scc_v)

    ri_map = {}
    for u in range(scc_num):
        r_i = uf.get_root(u)
        if r_i not in ri_map:
            ri_map[r_i] = []
        ri_map[r_i].append(u)

    scc_edges = set()
    for u, v in edges:
        scc_u = scc_labels[u]
        scc_v = scc_labels[v]
        if scc_u != scc_v:
            scc_edges.add((scc_u, scc_v))

    scc_next_nodes = [[] for _ in range(scc_num)]
    in_degree = [0] * scc_num
    for u, v in scc_edges:
        scc_next_nodes[u].append(v)
        in_degree[v] += 1

    queue = deque()    
    for scc_nodes in ri_map.values():
        for n in scc_nodes:
            if in_degree[n] == 0:
                queue.append(n)
        array = []        
        while len(queue) > 0:
            v = queue.popleft()
            array.append(v)
            for w in scc_next_nodes[v]:
                in_degree[w] -= 1
                if in_degree[w] == 0:
                    queue.append(w)

        for i in range(len(array) - 1):
            v1 = array[i]
            v2 = array[i + 1]
            n1 = scc_map[v1][0]
            n2 = scc_map[v2][0]
            answer.append((n1, n2))
    
    print(len(answer))
    for u, v in answer:
        print(u + 1, v + 1)




if __name__ == "__main__":
    main()