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

from collections import deque

def scc(N, next_nodes):
    """
    有向グラフにおける強連結成分分解
    """
    # 深さ優先探索をしてラベリング
    stack = deque()
    v_list = []
    parents = [-2] * N
    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:
                    v_list.append(v)
    
    # 逆グラフの生成
    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_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)
    
    # 連結成分ごとに問題を分解
    uf = UnionFind(N)
    for u, v in edges:
        uf.merge(u, v)

    components_map = {}
    for i in range(N):
        root_i = uf.get_root(i)
        if root_i not in components_map:
            components_map[root_i] = []
        components_map[root_i].append(i)
    
    answer = []    
    in_degrees = [0] * N
    for _, v in edges:
        in_degrees[v] += 1

    for nodes in components_map.values():

        scc_set = set()
        for n in nodes:
            sccx = scc_labels[n]
            scc_set.add(sccx)
    
        if len(scc_set) < len(nodes):
            for i in range(len(nodes)):
                v = nodes[i]
                w = nodes[(i + 1) % len(nodes)]
                answer.append((v, w))
        else:
            queue = deque()
            for n in nodes:
                if in_degrees[n] == 0:
                    queue.append(n)
                
            array = []
            while len(queue) > 0:
                v = queue.popleft()
                array.append(v)
                for w in next_nodes[v]:
                    in_degrees[w] -= 1
                    if in_degrees[w] == 0:
                        queue.append(w)
            
            for i in range(len(nodes) - 1):
                v = array[i]
                w = array[(i + 1) % len(nodes)]
                answer.append((v, w))
            

    print(len(answer))
    for u, v in answer:
        print(u + 1, v + 1)


            






if __name__ == "__main__":
    main()