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 <cstddef>
#include <utility>
#include <queue>
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
namespace loquat {
using vertex_t = size_t;
}
namespace loquat {
namespace edge_param {
struct to_ {
	vertex_t to;
	explicit to_(vertex_t t = 0)
		: to(t)
	{ }
};
}
namespace detail {
template <typename T, typename... Params>
struct edge_param_wrapper : public T, edge_param_wrapper<Params...> {
};
template <typename T>
struct edge_param_wrapper<T> : public T {
	template <typename U>
	explicit edge_param_wrapper(U&& x)
		: T(std::forward<U>(x))
	{ }
};
}
template <typename... Params>
struct edge : public detail::edge_param_wrapper<edge_param::to_, Params...> {
	template <typename... Args>
	explicit edge(Args&&... args)
		: detail::edge_param_wrapper<edge_param::to_, Params...>(
			std::forward<Args>(args)...)
	{ }
};
}
namespace loquat {
template <typename EdgeType>
class adjacency_list {
public:
	using edge_type = EdgeType;
	using edge_list = std::vector<edge_type>;
private:
	std::vector<std::vector<EdgeType>> m_edges;
public:
	explicit adjacency_list(size_t n)
		: m_edges(n)
	{ }
	const edge_list& operator[](vertex_t u) const {
		return m_edges[u];
	}
	template <typename... Args>
	void add_edge(vertex_t from, Args&&... args){
		m_edges[from].emplace_back(std::forward<Args>(args)...);
	}
};
}
namespace loquat {
class disjoint_set {
public:
	using value_type = size_t;
private:
	std::vector<value_type> m_parents;
	std::vector<value_type> m_ranks;
public:
	explicit disjoint_set(size_t n)
		: m_parents(n)
		, m_ranks(n)
	{
		for(size_t i = 0; i < n; ++i){
			m_parents[i] = i;
		}
	}
	value_type find(size_t x){
		if(m_parents[x] == x){ return x; }
		m_parents[x] = find(m_parents[x]);
		return m_parents[x];
	}
	value_type unite(size_t x, size_t y){
		x = find(x);
		y = find(y);
		if(x == y){ return x; }
		if(m_ranks[x] < m_ranks[y]){
			m_parents[x] = y;
			return y;
		}else if(m_ranks[x] > m_ranks[y]){
			m_parents[y] = x;
			return x;
		}else{
			m_parents[y] = x;
			++m_ranks[x];
			return x;
		}
	}
	bool same(size_t x, size_t y){
		return find(x) == find(y);
	}
};
}
using namespace std;
using edge = loquat::edge<>;
using pii = pair<int, int>;
bool solve(
	vector<pii>& picks,
	vector<bool>& vis,
	int u, int p,
	const loquat::adjacency_list<edge>& g)
{
	vis[u] = true;
	bool done = false;
	for(const auto& e : g[u]){
		const int v = e.to;
		if(vis[v]){ continue; }
		const auto f = solve(picks, vis, v, u, g);
		if(!f){ done = !done; }
	}
	if(!done && p >= 0){ picks.emplace_back(u, p); }
	return done;
}
int main(){
	ios_base::sync_with_stdio(false);
	int n, m;
	cin >> n >> m;
	vector<vector<int>> a(n, vector<int>(n));
	for(int i = 0; i < m; ++i){
		int u, v;
		cin >> u >> v;
		--u; --v;
		a[u][v] = a[v][u] = 1;
	}
	loquat::adjacency_list<edge> g(n), cg(n);
	for(int u = 0; u < n; ++u){
		for(int v = 0; v < n; ++v){
			if(u == v){ continue; }
			(a[u][v] ? g : cg).add_edge(u, v);
		}
	}
	if(n % 2 == 0){
		vector<pii> picks;
		vector<bool> vis(n);
		for(int r = 0; r < n; ++r){
			if(vis[r]){ continue; }
			if(!solve(picks, vis, r, -1, cg)){
				cout << -1 << endl;
				return 0;
			}
		}
		for(const auto& p : picks){
			const int u = p.first;
			const int v = p.second;
			a[u][v] = a[v][u] = 2;
		}
		loquat::disjoint_set ds(n);
		for(int u = 0; u < n; ++u){
			for(int v = u + 1; v < n; ++v){
				if(a[u][v] != 2){ ds.unite(u, v); }
			}
		}
		bool accept = true;
		for(int v = 0; v < n; ++v){
			if(!ds.same(0, v)){ accept = false; }
		}
		if(!accept){
			cout << -1 << endl;
			return 0;
		}
	}
	vector<pii> solution;
	for(int u = 0; u < n; ++u){
		for(int v = u + 1; v < n; ++v){
			if(a[u][v] == 0){ solution.emplace_back(u, v); }
		}
	}
	cout << solution.size() << endl;
	for(const auto& p : solution){
		cout << p.first + 1 << " " << p.second + 1 << endl;
	}
	return 0;
}