#pragma GCC optimize ("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;

struct UnionFind{
    vector<int> par,num;
    UnionFind(int n):par(n),num(n,1){
        iota(par.begin(),par.end(),0);  //include<numeric>
    }
    int find(int v){
        return (par[v]==v)?v:(par[v]=find(par[v]));
    }
    void unite(int u, int v){
        u = find(u),v = find(v);
        if(u == v) return;
        if(num[u] < num[v]) swap(u,v);
        num[u] += num[v];
        par[v] = u;
    }
    bool same(int u, int v){
        return find(u) == find(v);
    }
    int size(int v){
        return num[find(v)];
    }
};

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n,m; cin >> n >> m;
    vector<vector<bool>> g(n,vector<bool>(n));
    vector<int> deg(n);
    UnionFind uf(n);
    for (int i = 0; i < n; ++i) {
        g[i][i] = true;
    }
    for (int i = 0; i < m; ++i) {
        int x,y; cin >> x >> y;
        x--; y--;
        g[x][y] = g[y][x] = true;
        uf.unite(x, y);
        deg[x]++;
        deg[y]++;
    }
    vector<pair<int,int>> res;
    auto add = [&](int s,int t)->void{
        res.push_back({s, t});
        g[s][t] = g[t][s] = true;
        deg[s]++; deg[t]++;
        uf.unite(s, t);
    };
    // 孤立点を貪欲に処理
    {
        vector<int> one;
        vector<int> odd;
        for (int i = 0; i < n; ++i) {
            if(deg[i] == 0) one.push_back(i);
            if(deg[i] % 2 == 1) odd.push_back(i);
        }
        if(odd.size()){
            int s = odd.back();
            while(one.size()){
                int t = one.back(); one.pop_back();
                add(s, t);
                s = t;
            }
        }
    }
    vector<bool> used(n);
    // 次数の条件を揃える
    // 補グラフのdfs tree
    auto dfs = [&](auto dfs,int s,int p)->void{
        for (int i = 0; i < n; ++i) {
            if(g[s][i] or used[i]) continue;
            used[i] = true;
            dfs(dfs, i, s);
        }
        if(deg[s]%2 == 1){
            if(p == -1){
                cout << -1 << "\n"; exit(0);
            }
            add(s, p);
        }
    };
    for (int i = 0; i < n; ++i) {
        if(used[i]) continue;
        used[i] = true;
        dfs(dfs, i, -1);
    }
    // 連結にする
    vector<pair<int,int>> v;
    for (int i = 0; i < n; ++i) {
        if(uf.find(i) == i){
            int j = -1;
            for (int k = 0; k < n; ++k) {
                if(uf.same(i, k) and i != k){
                    j = k; break;
                }
            }
            v.push_back({i,j});
        }
    }
    if(v.size() == 2){
        if(v[1].second == -1) swap(v[0], v[1]);
        if(v[0].second != -1){
            add(v[0].first, v[1].first);
            add(v[0].first, v[1].second);
            add(v[0].second, v[1].first);
            add(v[0].second, v[1].second);
        }
        else{
            bool done = false;
            for (int i = 0; i < n; ++i) {
                if(done or i == v[0].first) continue;
                for (int j = 0; j < n; ++j) {
                    if(done or j == v[0].first) continue;
                    if(!g[i][j]){
                        done = true;
                        add(i, j);
                        add(i, v[0].first);
                        add(j, v[0].first);
                    }
                }
            }
            if(!done){
                cout << -1 << "\n"; return 0;
            }
        }
    }
    else if(v.size() >= 3){
        for (int i = 0; i < v.size(); ++i) {
            int j = i+1 < v.size() ? i+1 : 0;
            add(v[i].first, v[j].first);
        }
    }
    cout << res.size() << "\n";
    for(auto p:res){
        if(p.first > p.second) swap(p.first, p.second);
        cout << p.first+1 << " " << p.second+1 << "\n";
    }
}