#include <bits/stdc++.h>
#ifdef LOCAL
#include "cp_debug.h"
#else
#define debug(...) 42
#endif
#define rep(i,a,b) for(int i = a; i < b; ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;

template<typename T> void read(T &x){
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
    read(first);
    read(args...);
}
template<typename T> void write(T x) {
    if(x > 9) write(x/10);
    putchar(x%10 + '0');
}

void solve() {
    int n, m;
    read(n, m);
    vector<vi> G(n+1), nG(n+1);
    rep(i,0,m) {
        int u, v;
        read(u, v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    vi dfn(n+1), cyc_mark(n+1), fath(n+1), in_cyc(n+1), cyc_siz(n+1);

    vector<pii> ans;
    rep(i,1,n+1) if(!dfn[i]) {
        int dfs_clock = 0;
        vi this_cc;
        vector<pii> cyc_edges;
        function<void(int,int)> dfs = [&](int u, int fa) {
            this_cc.emplace_back(u);
            fath[u] = fa;
            dfn[u] = ++dfs_clock;
            for(auto v: G[u]) if(v != fa) {
                if(dfn[v] == 0) {
                    nG[u].emplace_back(v);
                    nG[v].emplace_back(u);
                    dfs(v, u);
                } else if(dfn[v] < dfn[u]) {
                    cyc_mark[u]++;
                    if(fath[v] != -1) {
                        cyc_mark[fath[v]]--;
                    }
                    cyc_edges.emplace_back(v, u);
                }
            }
        };
        dfs(i,-1);

        debug(nG);
        debug(dfn);
        debug(this_cc);
        debug(cyc_edges);
        debug(cyc_mark);

        if(cyc_edges.empty()) {
            // output all leaf -> parent edges
            for(auto u: this_cc) if(sz(G[u]) == 1) {
                ans.emplace_back(u, G[u][0]);
            }
        } else {
            function<void(int,int)> populate_cyc = [&](int u, int fa) {
                in_cyc[u] = cyc_mark[u];
                for(auto v: nG[u]) if(v != fa) {
                    populate_cyc(v,u);
                    in_cyc[u] += in_cyc[v];
                }
            };
            populate_cyc(i,-1);
            debug(in_cyc);

            int rt = cyc_edges[0].second;
            debug(rt);
            assert(in_cyc[rt] > 0);
            function<void(int,int)>  calc_cyc_comp = [&](int u, int fa) {
                cyc_siz[u] = in_cyc[u] > 0;
                for(auto v: nG[u]) if(v != fa) {
                    calc_cyc_comp(v,u);
                    cyc_siz[u] += cyc_siz[v];
                }
            };
            calc_cyc_comp(rt,-1);
            debug(cyc_siz);

            for(auto u: this_cc) if(cyc_siz[u] > 0) {
                for(auto v: G[u]) if(cyc_siz[v] == 0) {
                    ans.emplace_back(u, v);
                }
            }
        }
        debug(ans);
    }
    sort(all(ans));
    cout<<sz(ans)<<'\n';
    for(auto [u, v]: ans) {
        cout<<u<<' '<<v<<'\n';
    }
}

signed main() {
    int T; T = 1;
    while(T--) solve();
    return 0;
}