#include<iomanip>
#include<limits>
#include<thread>
#include<utility>
#include<iostream>
#include<string>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<complex>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pi;
typedef pair<double,double> pd;
typedef pair<double,ll> pdl;
#define F first
#define S second
const ll E=1e18+7;
const ll MOD=1000000007;

vector<vector<ll>> A;

vector<ll> used;
vector<pll> ans;
ll n,m;


ll dfs(int p,int w){
    used[w]=1;
    ll count=-1;
    for(int i=0;i<n;i++){count+=A[w][i];}
    for(int i=0;i<n;i++){
        if(A[w][i]==0 && used[i]==0){
            count+=dfs(w,i);
        }
    }
    if(count&1){
        if(p==-1){return 1;}
        ans.push_back({min(w,p),max(w,p)});
        return A[w][p]=A[p][w]=1;
    }
    return 0;
}

pll connected(ll w){
    used[w]=1;
    ll c=-1;
    for(int i=0;i<n;i++){
        if(A[w][i]==1 && used[i]==0){
            c=max(c,connected(i).F);
        }
    }
    return {w,c};
}

vector<ll> Count;



int main(){
    cin>>n>>m;
    A.resize(n,vector<ll>(n,0));
    Count.resize(n,0);
    for(int i=0;i<m;i++){
        ll s,t;
        cin>>s>>t;
        s--; t--;
        A[s][t]++;
        A[t][s]++;
        Count[s]++;
        Count[t]++;
    }
    for(int i=0;i<n;i++){A[i][i]=1;}
    if(n&1){
        cout<<n*(n-1)/2-m<<endl;
        for(int i=0;i<n;i++){
            for(int t=i+1;t<n;t++){
                if(A[i][t]==0){
                    cout<<i+1<<" "<<t+1<<endl;
                }
            }
        }
        return 0;
    }
    used.resize(n,0);
    bool j=true;
    for(int i=0;i<n && j;i++){
        if(Count[i]==0){
            for(int t=0;t<n;t++){
                if(Count[t]&1){
                    A[i][t]=A[t][i]=1;
                    ans.push_back({min(i,t),max(i,t)});
                    j=false;
                    break;
                }
            }
        }
    }
    for(int i=0;i<n;i++){
        if(used[i]==0){
            if(dfs(-1,i)==1){cout<<-1<<endl; return 0;}
        }
    }
    for(int i=0;i<n;i++){used[i]=0;}
    vector<pll> G;
    for(int i=0;i<n;i++){
        if(used[i]==0){G.push_back(connected(i));}
    }
    if(G.size()>=3){
        for(int i=1;i<G.size();i++){
            ans.push_back({min(G[i-1].F,G[i].F),max(G[i-1].F,G[i].F)});
        }
        ans.push_back({min(G[0].F,G.back().F),max(G[0].F,G.back().F)});
    }
    else if(G.size()==2){
        if(G[0].S!=-1 && G[1].S!=-1){
            ans.push_back({min(G[0].F,G[1].F),max(G[0].F,G[1].F)});
            ans.push_back({min(G[0].S,G[1].F),max(G[0].S,G[1].F)});
            ans.push_back({min(G[0].F,G[1].S),max(G[0].F,G[1].S)});
            ans.push_back({min(G[0].S,G[1].S),max(G[0].S,G[1].S)});
        }
        else if(G[0].S==-1 && G[1].S==-1){
            cout<<-1<<endl; return 0;
        }
        else{
            cout<<-1<<endl; return 0;
        }
    }
    cout<<ans.size()<<endl;
    sort(ans.begin(),ans.end());
    for(int i=0;i<ans.size();i++){
        cout<<ans[i].F+1<<" "<<ans[i].S+1<<endl;
    }
    
    
    return 0;
}



Measured memory_bytes: 3256