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 <numeric>
#include <utility>
#include <vector>

using std::vector;
using graph = vector<vector<int>>;

/*

有向グラフ g の補グラフの、0 を根とする BFS 木を求める

*/
std::pair<graph, vector<int>> bfs_tree_of_complement(const graph &g) {
  const int n = g.size();

  graph bfs_tree(n);
  vector<int> roots;

  vector<int> list(n);
  std::iota(list.begin(), list.end(), 0);
  vector<decltype(list.begin())> pos(n);
  std::iota(pos.begin(), pos.end(), list.begin());

  auto que = list.begin();
  auto v = list.begin();
  while (v != list.end()) {
    if (v == que) {
      roots.push_back(*v);
      ++que;
    }
    auto end = list.end();
    for (const int u : g[*v]) {
      if (que <= pos[u]) {
        --end;
        *pos[u] = *end;
        std::swap(pos[u], pos[*end]);
        *end = u;
      }
    }
    while (que != end) {
      bfs_tree[*v].push_back(*que);
      ++que;
    }
    ++v;
  }

  return {bfs_tree, roots};
}

#include <algorithm>
#include <functional>
#include <iostream>
#include <tuple>
#include <unordered_set>
#include <utility>

int main() {
  int n, m;
  std::cin >> n >> m;

  const auto hasher = [n](const std::pair<int, int> &x) -> std::size_t {
    return x.first * n + x.second;
  };

  std::unordered_set<std::pair<int, int>, decltype(hasher)> ge(n, hasher),
      ae(n, hasher);

  graph g(n);
  for (int i = 0; i < m; ++i) {
    int a, b;
    std::cin >> a >> b;
    --a;
    --b;
    g[a].push_back(b);
    g[b].push_back(a);
    ge.insert({a, b});
  }

  graph add(n);

  {
    const auto tree = bfs_tree_of_complement(g);
    std::function<void(int)> dfs = [&](const int v) -> void {
      for (const int u : tree.first[v]) {
        dfs(u);
        if (g[u].size() % 2 == 1) {
          g[u].push_back(v);
          g[v].push_back(u);
          ae.insert(std::minmax(u, v));
        }
      }
    };
    for (const auto r : tree.second) {
      dfs(r);
      if (g[r].size() % 2 == 1) {
        std::cout << "-1\n";
        return 0;
      }
    }
  }

  vector<vector<int>> cs;

  {
    vector<bool> visited(n, false);
    std::function<void(int)> dfs = [&](const int v) -> void {
      visited[v] = true;
      cs.back().push_back(v);
      for (const int u : g[v]) {
        if (not visited[u]) {
          dfs(u);
        }
      }
    };
    for (int i = 0; i < n; ++i) {
      if (not visited[i]) {
        cs.emplace_back();
        dfs(i);
      }
    }
  }

  int k = cs.size();

  if (k > 2) {
    for (int i = 0; i < k; ++i) {
      int a = cs[i][0];
      int b = cs[(i + 1) % k][0];
      ae.insert(std::minmax(a, b));
    }
  } else if (k == 2) {
    if (cs[1].size() == 1) {
      std::swap(cs[0], cs[1]);
    }
    if (cs[0].size() == 1) {
      int kk = cs[1].size();
      bool f = true;
      for (int i = 0; i < kk and f; ++i) {
        for (int j = i + 1; j < kk and f; ++j) {
          int a = cs[1][i];
          int b = cs[1][j];
          std::tie(a, b) = std::minmax({a, b});
          if (ae.count({a, b})) {
            f = false;
            ae.erase({a, b});
            ae.insert(std::minmax(cs[0][0], a));
            ae.insert(std::minmax(cs[0][0], b));
          } else if (ge.count({a, b}) == 0) {
            f = false;
            ae.insert({a, b});
            ae.insert(std::minmax(cs[0][0], a));
            ae.insert(std::minmax(cs[0][0], b));
          }
        }
      }
      if (f) {
        std::cout << "-1\n";
        return 0;
      }
    } else {
      for (const int a : {cs[0][0], cs[0][1]}) {
        for (const int b : {cs[1][0], cs[1][1]}) {
          ae.insert(std::minmax(a, b));
        }
      }
    }
  }

  std::cout << ae.size() << "\n";

  for (const auto &e : ae) {
    std::cout << e.first + 1 << " " << e.second + 1 << "\n";
  }

  return 0;
}