using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Numerics;
using System.Threading.Tasks;
using static System.Console;
using static System.Math;
using static Func;
class Z { static void Main() => new K(); }
class K
{
	int F => int.Parse(Str);
	long FL => long.Parse(Str);
	int[] G => Strs.Select(int.Parse).ToArray();
	uint[] GU => Strs.Select(uint.Parse).ToArray();
	decimal[] GD => Strs.Select(decimal.Parse).ToArray();
	long[] GL => Strs.Select(long.Parse).ToArray();
	string Str => ReadLine();
	string[] Strs => Str.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
	static ulong One(int k) => 1ul << k;
	static ulong All(int k) => One(k) - 1;
	static bool Has(ulong s, int k) => (s & One(k)) != 0;
	const int MOD = 1000000007;
	public K()
	{
		SetOut(new StreamWriter(OpenStandardOutput()) { AutoFlush = false });
		Solve();
		Out.Flush();
	}
	void Solve()
	{
		var I = G;
		int V = I[0], E = I[1];
		if (E % 2 != 0) { WriteLine(-1); return; }
		var uf = new UnionFindTree(V);
		var g = MakeArray(V, _ => new List<int>());
		for (var i = 0; i < E; i++)
		{
			I = G;
			I[0]--; I[1]--;
			g[I[0]].Add(I[1]);
			g[I[1]].Add(I[0]);
			uf.UniteCategory(I[0], I[1]);
		}
		var rs = MakeArray(V, _ => new List<int>());
		for (var i = 0; i < V; i++) rs[uf.GetRootOf(i)].Add(i);
		var ans = new List<Edge>();
		for (var r = 0; r < V; r++) if (r == uf.GetRootOf(r))
			{
				var deg = 0;
				foreach (var v in rs[r]) deg += g[v].Count;
				deg /= 2;
				if (deg % 2 != 0) { WriteLine(-1); return; }
				var V2 = rs[r].Count;
				var flag = new bool[V2];
				var st = new Stack<Pair>();
				var par = new int[V2];
				var d = new int[V2];
				var used = new HashSet<Edge>();
				st.Push(new Pair(-1, r, 0));
				while (st.Count > 0)
				{
					var pair = st.Pop();
					if (flag[pair.V]) continue;
					flag[pair.V] = true;
					par[pair.V] = pair.P;
					d[pair.V] = pair.D;
					if (pair.P >= 0) used.Add(new Edge(pair.P, pair.V));
					foreach (var u in g[pair.V]) if (!flag[u]) st.Push(new Pair(pair.V, u, pair.D + 1));
				}
				var parity = new int[V2];
				foreach (var u in rs[r])
					foreach (var v in g[u])
					{
						if (u > v) continue;
						var e = new Edge(u, v);
						if (!used.Contains(e))
						{
							ans.Add(e);
							parity[u]++;
						}
					}
				rs[r].Sort((u, v) => d[v].CompareTo(d[u]));
				foreach (var u in rs[r])
				{
					if (u == r) continue;
					if (parity[u] % 2 == 0)
					{
						ans.Add(new Edge(par[u], u));
						parity[par[u]]++;
					}
					else
					{
						ans.Add(new Edge(u, par[u]));
						parity[u]++;
					}
				}
			}
		foreach (var e in ans) WriteLine($"{e.S + 1} {e.T + 1}");
	}
}
struct Edge : IEquatable<Edge>
{
	public readonly int S, T;
	public Edge(int s, int t) { S = s; T = t; }
	public bool Equals(Edge other) => (S == other.S && T == other.T) || (T == other.S && S == other.T);
	public override int GetHashCode() => S.GetHashCode() ^ T.GetHashCode();
}
struct Pair
{
	public readonly int P, V, D;
	public Pair(int p, int v, int d) { P = p; D = d; V = v; }
}
static class Func
{
	public static T[] ConstantArray<T>(int n, T val) { var a = new T[n]; for (var i = 0; i < n; i++) a[i] = val; return a; }
	public static T[] MakeArray<T>(int n, Func<int, T> f) { var a = new T[n]; for (var i = 0; i < n; i++) a[i] = f(i); return a; }
	public static T[] Recurse<T>(int n, T a0, Func<int, T, T> f) { var a = new T[n]; a[0] = a0; for (var i = 1; i < n; i++) a[i] = f(i, a[i - 1]); return a; }
	public static T[] Accumulate<T>(IList<T> a, T zero, Func<T, T, T> f) { var s = new T[a.Count + 1]; s[0] = zero; for (var i = 0; i < a.Count; i++) s[i + 1] = f(s[i], a[i]); return s; }
	public static int FirstBinary(int min, int max, Predicate<int> pred)
	{
		while (min < max)
		{
			var mid = (min + max) / 2;
			if (pred(mid)) max = mid;
			else min = mid + 1;
		}
		return min;
	}
	public static long GCD(long a, long b)
	{
		var n = (ulong)Math.Abs(a); var m = (ulong)Math.Abs(b);
		if (n == 0) return (long)m; if (m == 0) return (long)n;
		int zm = 0, zn = 0;
		while ((n & 1) == 0) { n >>= 1; zn++; }
		while ((m & 1) == 0) { m >>= 1; zm++; }
		while (m != n)
		{
			if (m > n) { m -= n; while ((m & 1) == 0) m >>= 1; }
			else { n -= m; while ((n & 1) == 0) n >>= 1; }
		}
		return (long)n << Math.Min(zm, zn);
	}
	public static long Inverse(long a, long mod)
	{
		if (a < 0) { a %= mod; if (a < 0) a += mod; }
		var t = SolveLinear(a, mod);
		return t.Item1 > 0 ? t.Item1 : t.Item1 + mod;
	}
	public static long Pow(long a, long b, long mod)
	{
		var p = 1L;
		var x = a;
		while (b > 0)
		{
			if ((b & 1) == 1) p = (p * x) % mod;
			b >>= 1;
			x = (x * x) % mod;
		}
		return p;
	}
	public static Tuple<long, long> SolveLinear(long n, long m)
	{
		if (n < 0) { var p = SolveLinear(-n, m); return p == null ? p : new Tuple<long, long>(-p.Item1, p.Item2); }
		if (m < 0) { var p = SolveLinear(n, -m); return p == null ? p : new Tuple<long, long>(p.Item1, -p.Item2); }
		if (n < m) { var p = SolveLinear(m, n); return p == null ? p : new Tuple<long, long>(p.Item2, p.Item1); }
		long a = 1, b = 0, c = 0, d = 1;
		while (m > 0)
		{
			var r = n % m;
			var q = n / m;
			n = m;
			m = r;
			var tmp = a;
			a = -a * q + b;
			b = tmp;
			tmp = c;
			c = -c * q + d;
			d = tmp;
		}
		return n != 1 ? null : new Tuple<long, long>(d, b);
	}
}
class UnionFindTree
{
	int N;
	int[] parent, rank, size;
	public UnionFindTree(int capacity)
	{
		N = capacity;
		parent = new int[N];
		rank = new int[N];
		size = new int[N];
		for (var i = 0; i < N; i++) { parent[i] = i; size[i] = 1; }
	}
	public int GetSize(int x) => size[GetRootOf(x)];
	public int GetRootOf(int x) => parent[x] == x ? x : parent[x] = GetRootOf(parent[x]);
	public bool UniteCategory(int x, int y)
	{
		if ((x = GetRootOf(x)) == (y = GetRootOf(y))) return false;
		if (rank[x] < rank[y]) { parent[x] = y; size[y] += size[x]; }
		else
		{
			parent[y] = x; size[x] += size[y];
			if (rank[x] == rank[y]) rank[x]++;
		}
		return true;
	}
	public bool IsSameCategory(int x, int y) => GetRootOf(x) == GetRootOf(y);
}


Measured memory_bytes: 46204