Problem: Eulerian Flight Tour

You have an airline route map of a certain region. All the airports in the region and all the non-stop routes between them are on the map. Here, a non-stop route is a flight route that provides non-stop flights in both ways.

Named after the great mathematician Leonhard Euler, an Eulerian tour is an itinerary visiting all the airports in the region taking a single flight of every non-stop route available in the region. To be precise, it is a list of airports, satisfying all of the following.

* The list begins and ends with the same airport.
* There are non-stop routes between pairs of airports adjacent in the list.
* All the airports in the region appear at least once in the list. Note that it is allowed to have some airports appearing multiple times.
* For all the airport pairs with non-stop routes in between, there should be one and only one adjacent appearance of two airports of the pair in the list in either order.



It may not always be possible to find an Eulerian tour only with the non-stop routes listed in the map. Adding more routes, however, may enable Eulerian tours. Your task is to find a set of additional routes that enables Eulerian tours.

Input

The input consists of a single test case.


$n$ $m$
$a_1$ $b_1$
...
$a_m$ $b_m$


$n$ ($3 \leq n \leq 100$) is the number of airports. The airports are numbered from 1 to $n$. $m$ ($0 \leq m \leq \frac{n(n-1)}{2}$) is the number of pairs of airports that have non-stop routes. Among the $m$ lines following it, integers $a_i$ and $b_i$ on the $i$-th line of them ($1 \leq i \leq m$) are airport numbers between which a non-stop route is operated. You can assume $1 \leq a_i < b_i \leq n$, and for any $i \ne j$, either $a_i \ne a_j$ or $b_i \ne b_j$ holds.

Output

Output a set of additional non-stop routes that enables Eulerian tours. If two or more different sets will do, any one of them is acceptable. The output should be in the following format.


$k$
$c_1$ $d_1$
...
$c_k$ $d_k$


$k$ is the number of non-stop routes to add, possibly zero. Each of the following $k$ lines should have a pair of integers, separated by a space. Integers $c_i$ and $d_i$ in the $i$-th line ($c_i < d_i$) are airport numbers specifying that a non-stop route is to be added between them. These pairs, ($c_i, d_i$) for $1 \leq i \leq k$, should be distinct and should not appear in the input.

If adding new non-stop routes can never enable Eulerian tours, output -1 in a line.

Sample Input 1


4 2
1 2
3 4


Sample Output 1


2
1 4
2 3


Sample Input 2


6 9
1 4
1 5
1 6
2 4
2 5
2 6
3 4
3 5
3 6


Sample Output 2


-1


Sample Input 3


6 7
1 2
1 3
1 4
2 3
4 5
4 6
5 6


Sample Output 3


3
1 5
2 4
2 5


Sample Input 4


4 3
2 3
2 4
3 4


Sample Output 4


-1


Sample Input 5


5 5
1 3
1 4
2 4
2 5
3 5


Sample Output 5


0






Example

Input

4 2
1 2
3 4


Output

2
1 4
2 3

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<int, ll> pil;
typedef pair<int, ll> pli;
typedef pair<double,double> pdd;
#define SQ(i) ((i)*(i))
#define MEM(a, b) memset(a, (b), sizeof(a))
#define SZ(i) int(i.size())
#define FOR(i, j, k, in) for (int i=j ; i<k ; i+=in)
#define RFOR(i, j, k, in) for (int i=j ; i>=k ; i-=in)
#define REP(i, j) FOR(i, 0, j, 1)
#define REP1(i,j) FOR(i, 1, j+1, 1)
#define RREP(i, j) RFOR(i, j, 0, 1)
#define ALL(_a) _a.begin(),_a.end()
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define X first
#define Y second
#ifdef tmd
#define TIME(i) Timer i(#i)
#define debug(...) do{\
    fprintf(stderr,"%s - %d (%s) = ",__PRETTY_FUNCTION__,__LINE__,#__VA_ARGS__);\
    _do(__VA_ARGS__);\
}while(0)
template<typename T>void _do(T &&_x){cerr<<_x<<endl;}
template<typename T,typename ...S> void _do(T &&_x,S &&..._t){cerr<<_x<<" ,";_do(_t...);}
template<typename _a,typename _b> ostream& operator << (ostream &_s,const pair<_a,_b> &_p){return _s<<"("<<_p.X<<","<<_p.Y<<")";}
template<typename It> ostream& _OUTC(ostream &_s,It _ita,It _itb)
{
    _s<<"{";
    for(It _it=_ita;_it!=_itb;_it++)
    {
        _s<<(_it==_ita?"":",")<<*_it;
    }
    _s<<"}";
    return _s;
}
template<typename _a> ostream &operator << (ostream &_s,vector<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a> ostream &operator << (ostream &_s,set<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a> ostream &operator << (ostream &_s,deque<_a> &_c){return _OUTC(_s,ALL(_c));}
template<typename _a,typename _b> ostream &operator << (ostream &_s,map<_a,_b> &_c){return _OUTC(_s,ALL(_c));}
template<typename _t> void pary(_t _a,_t _b){_OUTC(cerr,_a,_b);cerr<<endl;}
#define IOS()
class Timer {
private:
    string scope_name;
    chrono::high_resolution_clock::time_point start_time;
public:
    Timer (string name) : scope_name(name) {
        start_time = chrono::high_resolution_clock::now();
    }
    ~Timer () {
        auto stop_time = chrono::high_resolution_clock::now();
        auto length = chrono::duration_cast<chrono::microseconds>(stop_time - start_time).count();
        double mlength = double(length) * 0.001;
        debug(scope_name, mlength);
    }
};
#else
#define TIME(i)
#define debug(...)
#define pary(...)
#define endl '\n'
#define IOS() ios_base::sync_with_stdio(0);cin.tie(0)
#endif

const ll MOD = 1000000007;
const ll INF = 0x3f3f3f3f3f3f3f3f;
const int iNF = 0x3f3f3f3f;
const ll MAXN = 102;

int n, m;
bool edge[MAXN][MAXN];
bool comp[MAXN][MAXN];
int deg[MAXN];
vector<pii> ans;

bool vis[MAXN];
void make_even (int nd) {
    vis[nd] = true;
    REP1 (i, n) {
        if (comp[nd][i] && !vis[i]) {
            make_even(i);
            if (deg[i] & 1) {
                deg[i]++;
                deg[nd]++;
                edge[i][nd] = true;
                edge[nd][i] = true;
                ans.eb(i, nd);
            }
        }
    }
}

void dfs (int nd, vector<int> &cur) {
    vis[nd] = true;
    cur.eb(nd);
    REP1 (i, n) {
        if (!vis[i] && edge[i][nd]) {
            dfs(i, cur);
        }
    }
}
/********** Good Luck :) **********/
int main () {
    TIME(main);
    IOS();

    cin >> n >> m;
    
    REP1 (i, n) {
        REP1 (j, n) {
            comp[i][j] = true;
        }
    }
    REP (i, m) {
        int u, v;
        cin >> u >> v;
        edge[u][v] = true;
        edge[v][u] = true;
        comp[u][v] = false;
        comp[v][u] = false;
        deg[u]++;
        deg[v]++;
    }

    REP1 (i, n) {
        if (!vis[i]) {
            make_even(i);
            if (deg[i] & 1) {
                cout << -1 << endl;
                return 0;
            }
        }
    }

    MEM(vis, 0);
    vector<vector<int> > cc;
    REP1 (i, n) {
        if (!vis[i]) {
            vector<int> cur;
            dfs(i, cur);
            cc.eb(cur);
        }
    }

    debug(cc);
    if (SZ(cc) == 2) {
        if (min(SZ(cc[0]), SZ(cc[1])) == 1) {
            bool rsv = false;
            if (SZ(cc[0]) < SZ(cc[1])) {
                swap(cc[0], cc[1]);
            }
            for (auto c1 : cc[0]) {
                for (auto c2 : cc[0]) {
                    if (rsv) {
                        break;
                    }
                    debug(c1, c2, edge[c1][c2]);
                    if (c1 != c2 && !edge[c1][c2]) {
                        rsv = true;
                        ans.eb(c1, c2);
                        ans.eb(c1, cc[1][0]);
                        ans.eb(c2, cc[1][0]);
                    }
                }
            }
            if (!rsv) {
                cout << -1 << endl;
                return 0;
            }
        } else {
            REP (i, 2) {
                REP (j, 2) {
                    ans.eb(cc[0][i], cc[1][j]);
                }
            }
        }
    } else if (SZ(cc) >= 3) {
        REP (i, SZ(cc)) {
            ans.eb(cc[i][0], cc[(i+1)%SZ(cc)][0]);
        }
    }

    cout << SZ(ans) << endl;
    for (auto p : ans) {
        if (p.X > p.Y) {
            swap(p.X, p.Y);
        }
        cout << p.X << " " << p.Y << endl;
    }
    return 0;
}