#include <iostream>
#include <fstream>
#include <vector>
#include <stack>
#include <algorithm>
#include <map>


using namespace std;
ifstream fin ("plan.in");
ofstream fout ("plan.out");
stack <int> st;
map <pair <int, int>, int> fr;
bool viz1[300], viz2[300];
int n, m;
vector <int> v[300], tr[300];
vector <int> rasp[300];
int comp[300];
int nr_comp;
int in[300];
int out[300];
map <pair<int, int>, int> put_edges;

vector <pair <int, int> > edges;

void dfs1 (int nod) {
    viz1[nod] = 1;

    for (auto it : v[nod])
        if (!viz1[it])
            dfs1(it);

    st.push(nod);
}

void dfs2(int nod) {
    viz2[nod] = 1;
    comp[nod] = nr_comp;
    rasp[nr_comp].push_back(nod);
    for (auto it: tr[nod])
        if (!viz2[it])
            dfs2(it);
}
int main () {
    fin >> n >> m;
    for (int i = 1; i<=m; ++i) {
        int a, b;
        fin >> a >> b;
        if (fr[ {a, b}] != 1 && a != b) {
            v[a].push_back(b);
            edges.push_back({a, b});
            fr[ {a, b}] = 1;
            tr[b].push_back(a);
        }
    }

    for (int i = 1; i<=n; ++i)
        if (!viz1[i])
            dfs1(i);

    while (!st.empty()) {
        int nod = st.top();
        st.pop();

        if (!viz2[nod]) {
            nr_comp++;
            dfs2(nod);
        }
    }

    for (auto edge:edges) {

        if (put_edges[ {comp[edge.first], comp[edge.second]}] == 1)
            continue;

        put_edges[ {comp[edge.first], comp[edge.second]}] = 1;
        in[comp[edge.second]]++;
        out[comp[edge.first]]++;
    }

    int need_in = 0;
    int need_out = 0;
    for (int i = 1; i <= nr_comp; ++i) {
        need_in += (in[i] == 0);
        need_out += (out[i] == 0);
    }

    vector <int> inuri;
    vector <int> outuri;

    for (int i = 1; i <= nr_comp; ++i)
        if (in[i] == 0)
            inuri.push_back(i);

    for (int i = nr_comp; i >= 1; --i)
        if (out[i] == 0)
            outuri.push_back(i);

    vector <pair <int, int> > ans;

    if (inuri.size() == 0)
        inuri.push_back(1);
    if (outuri.size() == 0)
        outuri.push_back(1);

    for (int i = 0; i < max(outuri.size(), inuri.size()); ++i)
        ans.push_back({rasp[outuri[min(i, (int) outuri.size() - 1)]][0], rasp[inuri[min(i, (int)inuri.size() - 1)]][0]});

    if (max(need_in, need_out) == 0) {
        fout << 0;
        return 0;
    }

    //fout << max(need_in, need_out) << '\n';
    fout << ans.size() << '\n';

    for (auto it : ans)
        fout << it.first << ' ' << it.second << '\n';
    return 0;

}

/*
6 7
1 2
2 3
3 1
4 1
4 5
5 6
6 4

*/