#include <iostream>
#include <vector>
#include <algorithm>

const int MAX_N = 500000;

using namespace std;

int n;
vector<int> graph[MAX_N + 1];

int parent[MAX_N + 1], depth[MAX_N + 1];
bool trav[MAX_N + 1];
void search0(int v, int& se) {
    if (trav[v]) return;
    trav[v] = true;
    for (int& e : graph[v]) {
        if (e == parent[v]) continue;
        if (trav[e]) {
            se = e;
            e = -e;
        } else {
            parent[e] = v;
            depth[e] = depth[v] + 1;
            search0(e, se);
        }
    }
}

bool istree[MAX_N + 1];
int crosscount[MAX_N + 1];
void search1(int v) {
    istree[v] = true;
    crosscount[v] = 0;
    for (const int& e : graph[v]) {
        if (e == parent[v]) continue;
        if (e < 0) {
            istree[v] = false;
            if (depth[-e] < depth[v]) crosscount[v]++;
            if (depth[-e] > depth[v]) crosscount[v]--;
        } else {
            search1(e);
            istree[v] &= istree[e];
            crosscount[v] += crosscount[e];
        }
    }
}

vector<pair<int,int>> res;
void search2(int v) {
    for (const int& e : graph[v]) {
        if (e == parent[v]) continue;
        if (e < 0) continue;
        if (crosscount[e] == 0 && istree[e]) {
            res.push_back({v, e});
        } else {
            search2(e);
        }
    }
}

void search3(int v) {
    if (!trav[v]) return;
    trav[v] = false;
    for (int& e : graph[v]) {
        e = abs(e);
        if (!trav[e]) continue;
        search3(e);
    }
}

void search4(int v) {
    int c = 0;
    for (const int& e : graph[v]) {
        if (e < 0) continue;
        if (c == 0) {
            c = e;
        } else {
            c = -1;
        }
        if (e == parent[v]) continue;
        search4(e);
    }
    if (c > 0) {
        res.push_back({v, c});
    }
}

int main() {
    int m;
    cin >> n >> m;
    for (int i = 0, f, t; i < m; ++i) {
        cin >> f >> t;
        graph[f].push_back(t);
        graph[t].push_back(f);
    }
    fill(trav + 1, trav + (n + 1), false);
    for (int i = 1; i <= n; ++i) {
        if (trav[i]) continue;
        parent[i] = 0;
        depth[i] = 0;
        int se = 0;
        int re;
        search0(i, se);
//        cout << se << endl;
        if (se > 0) {
            search3(i);
            parent[se] = 0;
            depth[se] = 0;
            search0(se, re);
//            for (int j = 1; j <= n; ++j) {
//                cout << j << " : ";
//                for (const int& e : graph[j]) cout << e << ' '; cout << endl;
//            }
            search1(se);
            search2(se);
        } else {
            search1(i);
            search4(i);
        }
    }
    cout << res.size() << endl;
    sort(res.begin(), res.end());
    for (const auto& p : res) {
        cout << p.first << ' ' << p.second << endl;
    }

    return 0;
}