#include<iostream>

#include<cstdio>

#include<cmath>

#include<cstdlib>

#include<cstring>

#include<algorithm>

using namespace std;

#define ll long long

#define N 10010

#define M 300010

#define S 0

#define T 10001

char getc(){char c=getchar();while (c==||c==||c==) c=getchar();return c;}

int gcd(int n,int m){return m==?n:gcd(m,n%m);}

int read()

{

    int x=,f=;char c=getchar();

    while (c<''||c>'') {if (c=='-') f=-;c=getchar();}

    while (c>=''&&c<='') x=(x<<)+(x<<)+(c^),c=getchar();

    return x*f;

}

int n,m,p[N],t=-,color[N],ans;

int d[N],q[N],cur[N];

struct data{int to,nxt,cap,flow;

}edge[M<<];

struct data2

{

    int x,y;

    bool operator <(const data2&a) const

    {

        return x<a.x||x==a.x&&y<a.y;

    }

}v[M];

void addedge(int x,int y,int z)

{

    t++;edge[t].to=y,edge[t].nxt=p[x],edge[t].cap=z,edge[t].flow=,p[x]=t;

    t++;edge[t].to=x,edge[t].nxt=p[y],edge[t].cap=,edge[t].flow=,p[y]=t;

}

void paint(int k)

{

    for (int i=p[k];~i;i=edge[i].nxt)

    if (color[edge[i].to]==-)

    {

        color[edge[i].to]=color[k]^;

        paint(edge[i].to);

    }

}

bool bfs()

{

    int head=,tail=;q[]=S;

    memset(d,,sizeof(d));d[S]=;

    do

    {

        int x=q[++head];

        for (int i=p[x];~i;i=edge[i].nxt)

        if (d[edge[i].to]==-&&edge[i].flow<edge[i].cap)

        {

            d[edge[i].to]=d[x]+;

            q[++tail]=edge[i].to;

        }

    }while (head<tail);

    return ~d[T];

}

int work(int k,int f)

{

    if (k==T) return f;

    int used=;

    for (int i=cur[k];~i;i=edge[i].nxt)

    if (d[k]+==d[edge[i].to])

    {

        int w=work(edge[i].to,min(f-used,edge[i].cap-edge[i].flow));

        edge[i].flow+=w,edge[i^].flow-=w;

        if (edge[i].flow<edge[i].cap) cur[k]=i;

        used+=w;if (used==f) return f;

    }

    if (used==) d[k]=-;

    return used;

}

void dinic()

{

    while (bfs())

    {

        memcpy(cur,p,sizeof(p));

        work(S,N);

    }

}

namespace newgraph

{

    int dfn[N]={},low[N]={},stk[N],id[N],top=,cnt=,tot=,t=,p[N]={},ans=;

    bool flag[N];

    struct data{int to,nxt;}edge[M];

    void addedge(int x,int y){t++;edge[t].to=y,edge[t].nxt=p[x],p[x]=t;}

    void tarjan(int k)

    {

        dfn[k]=low[k]=++cnt;

        stk[++top]=k;flag[k]=;

        for (int i=p[k];i;i=edge[i].nxt)

        if (!dfn[edge[i].to]) tarjan(edge[i].to),low[k]=min(low[k],low[edge[i].to]);

        else if (flag[edge[i].to]) low[k]=min(low[k],dfn[edge[i].to]);

        if (dfn[k]==low[k])

        {

            tot++;

            while (stk[top]!=k)

            {

                flag[stk[top]]=;

                id[stk[top]]=tot;

                top--;

            }

            flag[k]=;id[k]=tot;top--;

        }

    }

    void work()

    {

        for (int i=;i<=n;i++)

        if (!dfn[i]) tarjan(i);

        if (!dfn[T]) tarjan(T);

    }

}

int main()

{

#ifndef ONLINE_JUDGE

    freopen("a.in","r",stdin);

    freopen("a.out","w",stdout);

    const char LL[]="%I64d\n";

#else

    const char LL[]="%lld\n";

#endif

    n=read(),m=read();

    memset(p,,sizeof(p));

    for (int i=;i<=m;i++)

    {

        int x=read(),y=read();

        addedge(x,y,);

    }

    memset(color,,sizeof(color));

    for (int i=;i<=n;i++) if (color[i]==-) color[i]=,paint(i);

    for (int i=;i<=t;i++) edge[i].cap=color[edge[i^].to];

    for (int i=;i<=n;i++)

    if (color[i]) addedge(S,i,);

    else addedge(i,T,);

    dinic();

    for (int i=;i<=t;i++)

    if (edge[i].flow<edge[i].cap) newgraph::addedge(edge[i^].to,edge[i].to);

    newgraph::work();

    for (int i=;i<=t;i++)

    if (edge[i].cap==&&edge[i].flow==edge[i].cap&&edge[i^].to!=S&&edge[i].to!=T&&newgraph::id[edge[i^].to]!=newgraph::id[edge[i].to])

    ans++,v[ans].x=min(edge[i^].to,edge[i].to),v[ans].y=max(edge[i^].to,edge[i].to);

    sort(v+,v+ans+);

    cout<<ans<<endl;

    for (int i=;i<=ans;i++) printf("%d %d\n",v[i].x,v[i].y);

    return ;

}