#pragma GCC optimize (2)

#pragma G++ optimize (2)

#pragma comment(linker, "/STACK:102400000,102400000")

#include<bits/stdc++.h>

#include<cstdio>

#include<vector>

#define rep(i,a,b) for(int i=a;i<=b;i++)

#define dep(i,b,a) for(int i=b;i>=a;i--)

#define clr(a,b) memset(a,b,sizeof(a))

#define pb push_back

#define pii pair<int,int >

using namespace std;

typedef long long ll;

const int maxn=;

const int inf=0x3f3f3f3f;

ll rd()

{

    ll x=,f=;char ch=getchar();

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

    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}

    return x*f;

}

const ll INFLL = 0x3f3f3f3f3f3f3f3f;

const int INF = 0x3f3f3f3f;

struct Edge {

    int to, flow, nxt;

    Edge() {}

    Edge(int to, int nxt, int flow):to(to),nxt(nxt), flow(flow) {}

} edge[maxn << ];

int head[maxn], dep[maxn];

int S, T;

int N, n, m, tot,cnt;

vector<pair<int,int> >va;

void Init(int n) {

    N = n;

    for (int i = ; i <= N; ++i) head[i] = -;

    tot = ;

}

void addv(int u, int v, int w, int rw = ) {

    edge[tot] = Edge(v, head[u], w);

    head[u] = tot++;

    edge[tot] = Edge(u, head[v], rw);

    head[v] = tot++;

}

bool BFS() {

    for (int i = ; i <= N; ++i) dep[i] = -;

    queue<int>q;

    q.push(S);

    dep[S] = ;

    while (!q.empty()) {

        int u = q.front();

        q.pop();

        for (int i = head[u]; ~i; i = edge[i].nxt) {

            if (edge[i].flow && dep[edge[i].to] == -) {

                dep[edge[i].to] = dep[u] + ;

                q.push(edge[i].to);

            }

        }

    }

    return dep[T] <  ?  : ;

}

int DFS(int u, int f) {

    if (u == T || f == ) return f;

    int w, used = ;

    for (int i = head[u]; ~i; i = edge[i].nxt) {

        if (edge[i].flow && dep[edge[i].to] == dep[u] + ) {

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

            edge[i].flow -= w;

            edge[i ^ ].flow += w;

            used += w;

            if (used == f) return f;

        }

    }

    if (!used) dep[u] = -;

    return used;

}

int Dicnic() {

    int ans = ;

    while (BFS()) {

        ans += DFS(S, INF);

    }

    return ans;

}

int vs[][];

bool check(int res){

    Init(T);

    rep(i,,m){

        addv(i+n,T,);

    }

    rep(i,,n){

        addv(S,i,res);

    }

    rep(i,,m-){

        int u=va[i].first,v=va[i].second;

        addv(u,i++n,);

        addv(v,i++n,);

    }

    int flow=Dicnic();

    if(flow>=m){

        return true;

    }

    return false;

}

int main() {

    while (~scanf("%d %d", &n, &m)) {

        va.clear();

        S = , T = n+m+;

        rep(i,,m){

            int u,v;

            scanf("%d%d",&u,&v);

            va.push_back({u,v});

        }

        int l=,r=n+,mid,ans=-;

        while(l<=r){

            mid=(l+r)>>;

            if(check(mid)){

                ans=mid;

                r=mid-;

            }else{

                l=mid+;

            }

        }

        check(ans);

        printf("%d\n", ans);

        int flow=Dicnic();

        for(int u=;u<=n;u++){

            for(int i=head[u];i!=-;i=edge[i].nxt){

                if(edge[i].flow==&&edge[i].to>n){

                    int id=edge[i].to-n;

                    int x= (va[id-].first==u?va[id-].second:va[id-].first);

                        printf("%d %d\n",u,x);

                }

            }

        }

    }

}