#include <iostream>
#include <ctime>
#include <iomanip>
#include <vector>
#include <map>
#include <algorithm>
#include <string>
#include <cmath>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <cassert>
#include <queue>
#include <deque>
#include <climits>
#include <cstring>
#include <random>
#include <bitset>

using namespace std;

int n;
vector<int> used;
vector<int> ord;
vector<int> colors;
vector<vector<int>> g;
vector<vector<int>> inv;

vector<int> sz;
vector<vector<int>> is_edge_scc;


vector<pair<int, int>> edge_inside;

void set_edge_inside(int u, int v) {
    edge_inside.push_back({u + 1, v + 1});
}

void print_inside_edges() {
    for (auto t : edge_inside) {
        cout << t.first << ' ' << t.second << '\n';
    }
}

int init_reset_edge(int scc_num, const vector<unordered_set<int>> &ng) {
    int ans = 0;
    is_edge_scc.assign(scc_num, vector<int> (scc_num));
    for (int i = 0; i < (int)ng.size(); i++) {
        for (auto t : ng[i]) {
            is_edge_scc[i][t] = 1;
            ans++;
        }
    }
    return ans;
}

void reset_edge(int u, int v, vector<unordered_set<int>> &ng) {
    is_edge_scc.at(u).at(v) = 0;
    ng[u].erase(v);
}

void set_edge(int u, int v, vector<unordered_set<int>> &ng) {
    is_edge_scc.at(u).at(v) = 1;
    ng[u].insert(v);
}

void print_outside_edges() {
    vector<int> pr(n);
    for (int i = 0; i < n; i++) {
        pr[colors[i]] = i;
    }
    for (int i = 0; i < (int)is_edge_scc.size(); i++) {
        for (int j = 0; j < (int)is_edge_scc.size(); j++) {
            if (is_edge_scc[i][j]) {
                auto f = pr[i];
                auto s = pr[j];
                cout << f + 1 << ' ' << s + 1 << '\n';
            }
        }
    }
}

void dfs_connected(int cur, vector<int> &used, const vector<unordered_set<int>> &ng) {
    used[cur] = 1;
    for (auto t : ng[cur]) {
        if (!used[t]) {
            dfs_connected(t, used, ng);
        }
    }
}

bool is_connected(int u, int v, const vector<unordered_set<int>> &ng) {
    int cu = colors[u];
    int cv = colors[v];
    vector<int> used(ng.size());
    dfs_connected(cu, used, ng);
    return used[cv];
}

void dfs_scc_1(int cur) {
    used[cur] = 1;
    for (auto t : g[cur]) {
        if (!used[t]) {
            dfs_scc_1(t);
        }
    }
    ord.push_back(cur);
}

void dfs_scc_2(int cur, int clr, vector<int> &seen) {
    used[cur] = 1;
    colors[cur] = clr;
    sz[clr]++;
    seen.push_back(cur);
    for (auto t : inv[cur]) {
        if (!used[t]) {
            dfs_scc_2(t, clr, seen);
        }
    }
}

int ans_inside = 0;

vector<unordered_set<int>> scc() {
    used.assign(n, 0);
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            dfs_scc_1(i);
        }
    }
    colors.resize(n);
    used.assign(n, 0);
    reverse(ord.begin(), ord.end());
    int cnt = 0;
    vector<int> seen;
    for (auto t : ord) {
        if (!used[t]) {
            seen.clear();
            sz.push_back(0);
            dfs_scc_2(t, cnt, seen);
            cnt++;
            if (sz.back() != 1) {
                for (int i = 0; i < (int)seen.size(); i++) {
                    set_edge_inside(seen[i], seen[(i + 1) % seen.size()]);
                    ans_inside++;
                }
            }
        }
    }
    vector<unordered_set<int>> ans(cnt);
    for (int i = 0; i < n; i++) {
        for (auto t : g[i]) {
            if (colors[i] != colors[t]) {
                ans[colors[i]].insert(colors[t]);
            }
        }
    }
    return ans;
}

int solve() {
    //get_cyclic_scc
    vector<unordered_set<int>> ng;
    ng = scc();

    int ans_outside = init_reset_edge((int)ng.size(), ng);
    for (int i = 0; i < n; i++) {
        for (auto t : g[i]) {
            if (colors[i] != colors[t]) {
                reset_edge(colors[i], colors[t], ng);
                ans_outside--;
                auto tmp = is_connected(i, t, ng);
                if (!tmp) {
                    set_edge(colors[i], colors[t], ng);
                    ans_outside++;
                }
            }
        }
    }
    return ans_outside + ans_inside;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    #ifdef LOCAL
    assert(freopen("input.txt", "r", stdin));
    assert(freopen("output.txt", "w", stdout));
    #endif

    int m;
    cin >> n >> m;
    g.resize(n);
    inv.resize(n);
    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;
        u--;
        v--;
        g[u].push_back(v);
        inv[v].push_back(u);
    }

    cout << solve() << endl;
    print_outside_edges();
//    cout << '\n';
    print_inside_edges();
}