#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <functional>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    long long tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (long long)value;
    return output;
}

// 木のクラス。
// 有向グラフと同様に表現する。
// （Tipsに含まれている関数で、こちらに移植していないものがあるので注意。set_partial_size, get_children, rank_descending_ids, calc_diameter）
class Tree_New {
    public:
    struct Edge { 
        int to; int64_t cost;
    };
    typedef std::vector<std::vector<Edge>> adj_list;
    adj_list G;
    int node_num;
    Tree_New() {}
    Tree_New(const int node_num_in) {
        node_num = node_num_in;
        G.resize(node_num);
    }
    void add_directed_edge(const int from, const int to, const long long cost) {
        Edge edge; edge.to = to; edge.cost = cost;
        G[from].push_back(edge);
    }
    void add_undirected_edge(const int node1, const int node2, const long long cost) {
        add_directed_edge(node1, node2, cost);
        add_directed_edge(node2, node1, cost);
    }
    /*
    void cal_rank_child(int n, int r, int parent, std::vector<int>& rank) { // 辺が有向でも無向でも使える。呼び出すとき、parentは-1にしておくとよい。
        rank[n] = r;
        for (Edge e : G[n]) {
            if (e.to != parent) {
                cal_rank_child(e.to, r + 1, n, rank);
            }
        }
    }
    */
    std::vector<int> cal_rank(const int root) { // root を根としたときのrankを計算する。
        assert(root < node_num);
        std::vector<int> rank; rank.resize(node_num, -1);
        std::function<void(int, int, int)> dfs = [&] (int n, int r, int parent) {
            rank[n] = r;
            for (Edge e : G[n]) {
                if (e.to != parent) {
                    dfs(e.to, r + 1, n);
                }
            }
        };
        dfs(root, 0, -1);
        //cal_rank_child(root, 0, -1, rank);
        return rank;
    }
    std::vector<int> rank_descending_ids(const int root, const int begin, const int end) { // root を根としたときに、rankの降順にノード番号を並べる。
        assert(begin <= root && root <= end);
        assert(end < node_num);
        std::vector<int> rank = cal_rank(root);
        std::vector<int> ret;
        for (int i = begin; i <= end; i++) {
            ret.push_back(i);
        }
        std::sort(ret.begin(), ret.end(), [&](const int i, const int j) {
            return rank[i] > rank[j];
        });
        return ret;
    }
    std::vector<int> cal_partial_size(const int root) {
        // root を根としたとして各頂点を根とした部分木のサイズを求める。
        assert(root < node_num);
        std::vector<int> ret; ret.resize(node_num, 0);
        std::function<void(int, int)> dfs = [&] (int n, int parent) {
            for (Edge e : G[n]) {
                if (e.to != parent) {
                    dfs(e.to, n);
                    ret[n] += ret[e.to];
                }
            }
            ret[n] += 1;
        };
        dfs(root, -1);
        return ret;
    }

    /*
    void cal_parent_child(int n, int p, std::vector<int>& parent) {
        parent[n] = p;
        for (Edge e : G[n]) {
            if (e.to != p) {
                cal_parent_child(e.to, n, parent);
            }
        }
    };
    */
    std::vector<int> cal_parent(const int root) { // root を根としたときの親を計算する。有向木では行うまでもない。rootの親はrootとしておく。
        assert(root < node_num);
        std::vector<int> ret; ret.resize(node_num, -1);
        std::function<void(int, int)> dfs = [&] (int n, int p) {
            ret[n] = p;
            for (Edge e : G[n]) {
                if (e.to != p) {
                    dfs(e.to, n);
                }
            }
        };
        dfs(root, root);
        //cal_parent_child(root, root, parent);
        return ret;
    }
    std::vector<std::vector<int>> cal_parent_doubling(const int root) {
        // parentのダブリング構築。ret[i][n]は、nから2^iだけ親の方へ進んだ節点になる。
        std::vector<std::vector<int>> ret;
        std::vector<int> parent = cal_parent(root);
        ret.push_back(parent);
        while (true) {
            std::vector<int> pd; pd.resize(node_num);
            bool end_flag = true;
            for (int i = 0; i < node_num; i++) {
                if (ret.back()[i] == root || ret.back()[i] == -1) {
                    pd[i] = ret.back()[i];
                } else {
                    pd[i] = ret.back()[ret.back()[i]];
                    if (pd[i] != root) { 
                        end_flag = false;
                    }
                }
            }
            ret.push_back(pd);
            if (end_flag) { break; }
        }
        return ret;
    }
    int cal_ancestor(int node, int num, const std::vector<std::vector<int>>& parent_doubling) {
        // parent_doublingを利用して、nodeからnumだけ根の方向に進んだノードを求める。
        for (int i = 0; 0 < num; i++) {
            if (num % 2 == 1) {
                node = parent_doubling[i][node];
            }
            num /= 2;
        }
        return node;
    }
    int lca(int u, int v, const std::vector<int>& rank, const std::vector<std::vector<int>>& parent_doubling) {
        // rank と parent_doublingから、least common ancestorを計算。
        if (rank[u] < rank[v]) {
            v = cal_ancestor(v, rank[v] - rank[u], parent_doubling);
        } else {
            u = cal_ancestor(u, rank[u] - rank[v], parent_doubling);
        }
        assert(rank[v] == rank[u]);
        if (u == v) { return u; }
        int lb = 0; int ub = rank[u];
        while (lb + 1 < ub) {
            int mid = (lb + ub) / 2;
            if (cal_ancestor(u, mid, parent_doubling) == cal_ancestor(v, mid, parent_doubling)) {
                ub = mid;
            } else {
                lb = mid;
            }
        }
        return cal_ancestor(u, ub, parent_doubling);
    }

    void dfs_in_order_child(int n, int parent, std::vector<std::pair<int, int>>& order) {
        order.push_back({parent, n});
        for (Edge e : G[n]) {
            if (e.to != parent) {
                dfs_in_order_child(e.to, n, order);
            }
        }
        order.push_back({n, parent});
    } 
    std::vector<std::pair<int, int>> dfs_in_order(const int root) { 
        // root を根としたdfsで、通りがけ順に辺を並べる。オイラーツアーというらしい。
        // 全ての辺が、子に向かう方向と根に向かう方向でそれぞれ1度カウントされるので、サイズは(N-1)*2となる。
        assert(root < node_num);
        std::vector<std::pair<int, int>> order;
        for (Edge e : G[root]) {
            dfs_in_order_child(e.to, root, order);
        }
        return order;
    }
};

class Union_Find {
    public:
    std::vector<int> par;
    Union_Find() {}
    Union_Find(int n){
        par.resize(n, 0);
        reset();
    }

    void reset() {
        // サイズは変えずに初期状態に戻す。
        for (int i = 0; i < par.size(); i++) {
            par[i] = i;
        }
    }

    void simplify(int x) {
        std::vector<int> path;
        while (par[x] != x) {
            path.push_back(x);
            x = par[x];
        }
        for (int p : path) {
            par[p] = x;
        }
    }
    
    int find(const int x){
        simplify(x);
        return par[x];
    }
    
    void unite(int x, int y){
        x = find(x);
        y = find(y);
        if (x != y) {
            par[y] = x;
            // 改造する時は「根になっているノードの親を変更する」という原則が守られていることに注意。
        }
    }

    std::unordered_map<int, std::vector<int>> get_group(const int begin, const int end) {
        assert(0 <= begin && end < par.size());
        std::unordered_map<int, std::vector<int>> ret;
        for (int i = begin; i <= end; i++) {
            ret[find(i)].push_back(i);
        }
        return ret;
    }
};

const int MAX_N = 1e5 + 10;
const int MAX_M = 1e5 + 10;
int N, M;
int A[MAX_M], B[MAX_M];
int cnt[MAX_N] = {};

Union_Find uf(MAX_N);
Tree_New tree(MAX_N);
std::map<std::pair<int, int>, int> mp;

int main(int argc, char **argv) {
    std::cin >> N >> M;

    for (int i = 1; i <= M; i++) {
        std::cin >> A[i] >> B[i];
    }

    for (int i = 1; i <= M; i++) {
        if (uf.find(A[i]) != uf.find(B[i])) {
            mp[{A[i], B[i]}] = i;
            mp[{B[i], A[i]}] = i;
            tree.add_undirected_edge(A[i], B[i], 1);
            uf.unite(A[i], B[i]);
        } else {
            cnt[A[i]]++;
        }
    }

    auto rd = tree.rank_descending_ids(1, 1, N);
    auto parent = tree.cal_parent(1);

    for (auto i : rd) {
        if (i != 1) {
            int e = mp[{i, parent[i]}];
            if (cnt[i] % 2 == 0) {
                A[e] = parent[i];
                B[e] = i;
                cnt[parent[i]]++;
            } else {
                A[e] = i;
                B[e] = parent[i];
                cnt[i]++;
            }
        }
    }

    if (cnt[1] % 2 == 0) {
        for (int i = 1; i <= M; i++) {
            std::cout << A[i] << " " << B[i] << std::endl;
        }
    } else {
        std::cout << -1 << std::endl;
    }

    

    return 0;
}

Measured memory_bytes: 29876