#include <bits/stdc++.h>
using namespace std;
struct EulerianPath {
  struct Edge {
    int u, v, used;
    int getV(int p) { return (u == p) ? v : u; }
  };
  bool directed;
  vector<vector<int> > adj;
  vector<Edge> E;
  vector<int> cId, outDeg, inDeg;
  int N;
  EulerianPath(int N, int directed = false) {
    this->directed = directed;
    this->N = N;
    adj = vector<vector<int> >(N);
    cId = vector<int>(N);
    outDeg = vector<int>(N);
    inDeg = vector<int>(N);
  }
  void addEdge(int u, int v) {
    Edge e = (Edge){u, v, 0};
    adj[u].push_back(E.size());
    outDeg[u]++;
    inDeg[v]++;
    if (!directed) {
      adj[v].push_back(E.size());
      outDeg[v]++;
      inDeg[u]++;
    }
    E.push_back(e);
  }
  vector<int> getEulerPath() {
    int st = -1, cnt = 0;
    for (int i = 0; i < N; ++i) {
      if (st == -1 && outDeg[i]) st = i;
      if (directed) {
        int d = outDeg[i] - inDeg[i];
        if (d > 1) return vector<int>();
        if (d == 1) st = i, cnt++;
        if (cnt >= 2) return vector<int>();
      } else {
        int d = outDeg[i];
        if (d % 2 != 0) st = i, cnt++;
        if (cnt > 2) return vector<int>();
      }
    }
    stack<int> STK;
    STK.push(st);
    vector<int> ret;
    while (STK.size()) {
      int u = STK.top();
      bool found = false;
      while (cId[u] < adj[u].size()) {
        Edge &e = E[adj[u][cId[u]++]];
        if (e.used) continue;
        e.used = true;
        int v = e.getV(u);
        found = true;
        STK.push(v);
        break;
      }
      if (!found) {
        STK.pop();
        ret.push_back(u);
      }
    }
    reverse(ret.begin(), ret.end());
    return ret;
  }
};
int main() {
  int N, M;
  cin >> N >> M;
  EulerianPath G(N);
  for (int i = 0; i < M; ++i) {
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    G.addEdge(a, b);
  }
  vector<int> ODD;
  for (int i = 0, p = -1; i < N; ++i) {
    if (G.adj[i].size() % 2 == 1) {
      ODD.push_back(i);
    }
  }
  int E = M;
  for (int i = 0; i < ODD.size(); i += 2) {
    G.addEdge(ODD[i], ODD[i + 1]);
    E++;
  }
  vector<int> A = G.getEulerPath();
  cout << E + (E % 2 == 1) << endl;
  for (int i = 0; i + 1 < A.size(); i++) {
    if (i % 2 == 0)
      cout << A[i] + 1 << " " << A[i + 1] + 1 << endl;
    else
      cout << A[i + 1] + 1 << " " << A[i] + 1 << endl;
  }
  if (E % 2 == 1) {
    cout << A[E] + 1 << " " << 1 << endl;
  }
}
