#include <bits/stdc++.h>
using namespace std;
bool hadDebugEnv = false;
bool isDebugEnv = false;
bool isDebug() {
  if (!hadDebugEnv) {
    hadDebugEnv = true;
    isDebugEnv = (getenv("SWATMAD_CF_DEBUG") != NULL);
  }
  return isDebugEnv;
}
chrono::high_resolution_clock::time_point timeStart;
const int INF = numeric_limits<int>::max();
const long long LLINF = numeric_limits<long long>::max();
std::bitset<32> bits(int x) { return std::bitset<32>(x); }
template <class F, class S>
ostream& operator<<(ostream& o, const pair<F, S>& p) {
  return o << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& a);
template <class C>
void csp(ostream& o, const C& c) {
  bool f = 1;
  for (const auto& x : c) {
    if (!f) o << ", ";
    f = 0;
    o << x;
  }
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& a) {
  o << "[";
  csp(o, a);
  o << "]";
  return o;
}
template <class T>
ostream& operator<<(ostream& o, const vector<vector<T>>& a) {
  for (const auto& x : a) {
    o << "[";
    csp(o, x);
    o << "]\n";
  }
  return o;
}
template <class T, class R>
ostream& operator<<(ostream& o, const map<T, R>& a) {
  o << "{";
  csp(o, a);
  o << "}";
  return o;
}
template <class T, class R>
ostream& operator<<(ostream& o, const unordered_map<T, R>& a) {
  o << "{";
  csp(o, a);
  o << "}";
  return o;
}
template <class T>
ostream& operator<<(ostream& o, const set<T>& a) {
  o << "{";
  csp(o, a);
  o << "}";
  return o;
}
template <class T>
ostream& operator<<(ostream& o, const unordered_set<T>& a) {
  o << "{";
  csp(o, a);
  o << "}";
  return o;
}
struct Edge {
  int from;
  int to;
  int rev;
};
ostream& operator<<(ostream& os, const Edge& edge) {
  return os << edge.from << "|" << edge.to << "|" << edge.rev;
}
vector<int> eulerCycle(const vector<vector<Edge>>& a) {
  vector<vector<bool>> u(a.size());
  int m = 0;
  for (int i = 0; i < (int)(a.size()); ++i) {
    u[i].assign(a[i].size(), false);
    m += a[i].size();
  }
  vector<int> l(a.size(), 0);
  vector<int> cycle;
  cycle.reserve(m / 2);
  stack<int> s;
  s.push(0);
  while (!s.empty()) {
    int v = s.top();
    bool found = false;
    while (l[v] < a[v].size()) {
      int i = l[v];
      ++l[v];
      if (!u[v][i]) {
        const auto& e = a[v][i];
        u[v][i] = true;
        u[e.to][e.rev] = true;
        s.push(e.to);
        found = true;
        break;
      }
    }
    if (!found) {
      cycle.push_back(v);
      s.pop();
    }
  }
  return cycle;
}
int main() {
  if (isDebug()) {
    timeStart = chrono::high_resolution_clock::now();
  };
  int n;
  int m;
  cin >> n >> m;
  vector<vector<Edge>> a(n);
  vector<int> d(n, 0);
  vector<bool> h(n, false);
  for (int i = 0; i < (int)(m); ++i) {
    int f;
    int t;
    scanf("%d %d", &f, &t);
    --f;
    --t;
    if (f == t) {
      h[f] = true;
    }
    ++d[f];
    ++d[t];
    a[f].push_back({f, t, 0});
    int pos = a[f].size() - 1;
    a[t].push_back({t, f, pos});
    a[f][pos].rev = a[t].size() - 1;
  }
  vector<int> ne4;
  ne4.reserve(n);
  for (int i = 0; i < (int)(n); ++i) {
    if (d[i] % 2 == 1) {
      ne4.push_back(i);
    }
  }
  for (int i = 0; i < (int)(ne4.size() / 2); ++i) {
    int f = ne4[2 * i];
    int t = ne4[2 * i + 1];
    a[f].push_back({f, t, 0});
    int pos = a[f].size() - 1;
    ++d[f];
    a[t].push_back({t, f, pos});
    ++d[t];
    a[f][pos].rev = a[t].size() - 1;
    ++m;
  }
  if (isDebug()) {
    cerr << m << endl;
  };
  auto cycle = eulerCycle(a);
  vector<Edge> ans;
  ans.reserve(cycle.size());
  for (int i = 0; i < (int)(cycle.size() - 1); ++i) {
    if (i % 2 == 0) {
      ans.push_back({cycle[i], cycle[i + 1], 0});
    } else {
      ans.push_back({cycle[i + 1], cycle[i], 0});
    }
  }
  if (ans.size() % 2 == 1) {
    ans.push_back({ans.back().to, ans.back().to, 0});
  }
  printf("%d\n", int(ans.size()));
  for (const auto& e : ans) {
    printf("%d %d\n", e.from + 1, e.to + 1);
  }
  if (isDebug()) {
    cerr << "Time check: "
         << double(chrono::duration_cast<chrono::milliseconds>(
                       chrono::high_resolution_clock::now() - timeStart)
                       .count()) /
                1000
         << endl;
  };
  return 0;
}
