// Original C++ solution (slower):
#ifndef _GLIBCXX_NO_ASSERT

#include <cassert>

#endif

#include <cctype>

#include <cerrno>

#include <cfloat>

#include <ciso646>

#include <climits>

#include <clocale>

#include <cmath>

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>



#if __cplusplus >= 201103L

#include <ccomplex>

#include <cfenv>

#include <cinttypes>

#include <cstdbool>

#include <cstdint>

#include <ctgmath>

#include <cwchar>

#include <cwctype>

#endif



// C++

#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <istream>

#include <iterator>

#include <limits>

#include <list>

#include <locale>

#include <map>

#include <memory>

#include <new>

#include <numeric>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <typeinfo>

#include <utility>

#include <valarray>

#include <vector>



#if __cplusplus >= 201103L

#include <array>

#include <atomic>

#include <chrono>

#include <condition_variable>

#include <forward_list>

#include <future>

#include <initializer_list>

#include <mutex>

#include <random>

#include <ratio>

#include <regex>

#include <scoped_allocator>

#include <system_error>

#include <thread>

#include <tuple>

#include <typeindex>

#include <type_traits>

#include <unordered_map>

#include <unordered_set>

#endif

using namespace std;



typedef long long ll;

//typedef pair<int,int> Pint;

typedef pair<ll, ll> P;

//typedef pair<ll, pair<ll, ll>> P;

//typedef tuple<int,int,int> T;

typedef vector<ll> vec;

typedef vector<vec> mat;

#define rep(i, n) for(ll i = 0; i < n; i++)

#define revrep(i, n) for(ll i = n-1; i >= 0; i--)

#define pb push_back

#define f first

#define s second

const ll INFL = 1LL << 60;//10^18 = 2^60

const int INF = 1 << 30;//10^9

const ll MOD = 1e9 + 7;

//ll MOD  = 998244353;

vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};

vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};



ll max(ll a, ll b){return (a > b) ? a : b;}

ll min(ll a, ll b){return (a < b) ? a : b;}

ll pow_long(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2) res *= x;

    x *= x;

    k /= 2;

  }

  return res;

}



ll pow_mod(ll x, ll k){

  x %= MOD; x += MOD; x %= MOD;

  ll res = 1;

  while(k > 0){

    if(k % 2){

      res *= x; res %= MOD;

    }

    x *= x; x %= MOD;

    k /= 2;

  }

  return res;

}

ll inverse(ll x){return pow_mod(x, MOD - 2);};





ll gcd(ll a, ll b){

    if(b == 0) return a;

    return gcd(b, a % b);

}



ll lcm(ll x, ll y){return x / gcd(x, y) * y;};



ll N, M;

vector<ll> A(100010), B(100010);

vector<ll> cnt(100010);

vector<ll> par(100010);

vector<ll> E[100010];

vector<bool> visited(100010);

vector<ll> d(100010);

vector<pair<ll, ll>> dv;

void dfs(ll now, ll from){

  visited[now] = 1;

  par[now] = from;

  for(ll x : E[now]){

    if(visited[x]) continue;

    d[x] = d[now] + 1;

    dfs(x, now);

  }

}



map<pair<ll, ll>, int> dir;



int main(void){

  cin >> N >> M;

  rep(i, M){

    cin >> A[i] >> B[i];

    A[i]--, B[i]--;

    E[A[i]].pb(B[i]);

    E[B[i]].pb(A[i]);

    cnt[A[i]]++;

    dir[{A[i], B[i]}] = 0;

    dir[{B[i], A[i]}] = 0;

    //偶数で A -> B

  }

  if(M % 2){

    cout << -1 << endl;

    return 0;

  }

  visited[0] = 1;

  d[0] = 0;

  dfs(0, -1);

  dv.resize(N);

  rep(i, N){

    dv[i].f = d[i];

    dv[i].s = i;

  }

  sort(dv.begin(), dv.end());

  reverse(dv.begin(), dv.end());

  rep(i, N){

    if(cnt[dv[i].s] % 2){

      dir[{dv[i].s, par[dv[i].s]}]++;

      cnt[dv[i].s]++;

      cnt[par[dv[i].s]]++;

    }

  }

  rep(i, M){

    if((dir[{A[i], B[i]}] + dir[{B[i], A[i]}]) % 2){

      cout << B[i] + 1 << " " << A[i] + 1 << endl;

    }else{

      cout << A[i] + 1 << " " << B[i] + 1 << endl;

    }

  }



}


// Optimized solution to the same problem (faster):
//c++ -std=gnu++14 a.cpp

#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <iostream>

#include <istream>

#include <iterator>

#include <map>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <vector>

#include <tuple>

#include <iomanip>

#include <climits>

#include <fstream>

#include <random>

using namespace std;



typedef long long ll;

typedef unsigned long long ull;

//typedef pair<ll, ll> P;

#define rep(i, n) for(int i = 0; i < (n); i++)

#define revrep(i, n) for(int i = (n)-1; i >= 0; i--)

#define pb push_back

#define f first

#define s second

#define chmin(x, y) x = min(x, y);

#define chmax(x, y) x = max(x, y);

#define sz(x) ((int)(x).size())



//const ll INFL = LLONG_MAX;//10^18 = 2^60

const ll INFL = 1LL<<60;

//const int INF = INT_MAX;

const int INF = 1 << 30;//10^9

//const int MOD = 1000000007;

const int MOD = 998244353;

//int MOD = 1000000007;

double EPS = 1e-10;



vector<ll> dy = {0, 1, 0, -1, 1, 1, -1, -1, 0};

vector<ll> dx = {1, 0, -1, 0, 1, -1, 1, -1, 0};



void pres(double A){printf("%.12lf\n", A);}

void BinarySay(ll x, ll y = 60){rep(i, y) cout << (x>>(y-1-i) & 1); cout << endl;}

ll cnt_bit(ll x){return __builtin_popcountll(x);}



ll pow_long(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2) res *= x;

    x *= x; k /= 2;

  }

  return res;

}



ll pow_mod(ll x, ll k){

  x %= MOD;

  ll res = 1;

  while(k > 0){

    if(k % 2){

      res *= x; res %= MOD;

    }

    x *= x; x %= MOD;

    k /= 2;

  }

  return res;

}



ll inverse(ll x){return pow_mod(x, MOD - 2);};



ll gcd(ll a, ll b){

    if(b == 0) return a;

    return gcd(b, a % b);

}



ll lcm(ll x, ll y){

  ll res = x / gcd(x, y);

  res *= y;

  return res;

};





//コンビネーション

const int MAXcomb = 200010;

ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];

//facはn!,finvは1/n!

//invは逆元

void COMinit(){

    fac[0] = fac[1] = 1;

    finv[0] = finv[1] = 1;

    inv[1] = 1;

    for(int i = 2; i < MAXcomb; i++){

        fac[i] = fac[i-1] * i % MOD;

        inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;

        finv[i] = finv[i-1] * inv[i] % MOD;

    }

}

ll comb(int n, int k){

    if(n < k) return 0;

    if(n < 0 || k < 0) return 0;

    return fac[n] * finv[k] % MOD * finv[n-k] % MOD;

}



const int MAXkai = 200010;

ll kai_memo[MAXkai];

ll kai(ll N){

  if(kai_memo[N] != 0) return kai_memo[N];

  if(N <= 1) return 1;

  return kai_memo[N] = N * kai(N-1) % MOD;

}



ll disit(ll s, ll base = 10){

  ll res = 0;

  while(s){

    res++;

    s /= base;

  }

  return res;

}



//約数の列挙O(√n)

vector<int> divisor(int n){

    vector<int> res(0);

    for(int i = 1; i * i <= n; i++){

        if(n % i == 0){

            res.push_back(i);

            if(i != n/i) res.push_back(n/i);

        }

    }

    sort(res.begin(), res.end());

    return res;

}



int N, M;

int cnt[100010];

vector<int> E[100010];

bool visited[100010];

int par[100010];

vector<int> tree[100010];

map<pair<int, int>, int> dir;



void dfs(int now, int from){

  visited[now] = 1;

  par[now] = from;

  for(int to: E[now])if(to != from){

    if(visited[to]) continue;

    if(!dir[{now, to}]){

      dir[{now, to}] = 1;

      dir[{to, now}] = 0;

      cnt[now]++;

      cnt[to]--;

    }

    tree[now].pb(to);

    dfs(to, now);

  }

}



void make_ans(int now){

  for(int to: tree[now]) make_ans(to);

  if(cnt[now]&1){

    cnt[now]++;

    cnt[par[now]]--;

    dir[{now, par[now]}] = 1;

    dir[{par[now], now}] = 0;

  }

}



void solve(){

  cin >> N >> M;

  rep(i, M){

    int A, B;

    cin >> A >> B;

    A--, B--;

    E[A].pb(B);

    E[B].pb(A);

    dir[{A, B}] = 1;//A->B

    cnt[A]++;

  }

  if(M % 2){

    cout << -1 << endl;

    return;

  }

  dfs(0, -1);

  make_ans(0);

  rep(i, N)for(int to: E[i])if(i < to){

    if(dir[{i, to}]) cout << i+1 << " " << to+1 << endl;

    else cout << to+1 << " " << i+1 << endl;

  }

}



int main(){

  ios_base::sync_with_stdio(0);

  cin.tie(0), cout.tie(0);

  solve();

}


// Fastest known solution for this problem: