import java.io._
import java.util.StringTokenizer
import scala.util.control.Breaks.{breakable,break}
import scala.collection.mutable.{Map, Stack, Queue, PriorityQueue}

object Main extends App {
  val in = new InputReader(System.in)
  val pw = new PrintWriter(System.out)

  val N, M = in.next().toInt
  val graph = Array.fill[List[Int]](N+1)(Nil)
  for (i <- 1 to M) {
    val a, b = in.next().toInt
    graph(a) = b :: graph(a)
    graph(b) = a :: graph(b)
  }

  //
  if (M % 2 != 0)
    println(-1)
  else {
    val tree = Array.fill[List[Int]](N+1)(Nil)
    val dp = new Array[Boolean](N+1)
    val stack = new Stack[Int]
    dp(1) = true
    stack.push(1)
    while(!stack.isEmpty) {
      val n = stack.pop()
      for (e <- graph(n) if !dp(e)) {
        tree(n) = e :: tree(n)
        tree(e) = n :: tree(e)
        dp(e) = true
        stack.push(e)
      }
    }

    /////
    for (i <- 1 to N)
      dp(i) = false

    var ans: List[(Int, Int)] = Nil
    val degrees = new Array[Int](N+1)
    val traversed = new Array[Boolean](N+1)
    stack.push(1)
    traversed(1) = true
    while(!stack.isEmpty) {
      val n = stack.pop()

      if(tree(n).forall(x => traversed(x))) {
        dp(n) = true
        val cnt = graph(n).count(x => !dp(x))

        if (graph(n).forall(x => dp(x)))
          ()
        else {
          val targets = graph(n).filter(x => !dp(x))

          if((cnt + degrees(n)) % 2 == 1) {
            val i = targets.head
            degrees(i) += 1
            ans = (i, n) :: ans

            for (e <- targets.tail)
              ans = (n, e) :: ans
          }
          else {
            for (e <- targets)
              ans = (n, e) :: ans
          }
        }
      }
      else {
        stack.push(n)
        for (e <- tree(n) if !traversed(e)) {
          traversed(e) = true
          stack.push(e)
        }
      }

    }

    for ((a, b) <- ans)
      pw.println(s"$a $b")

    pw.flush()
  }
}


class InputReader(stream: InputStream) {
  private val reader = new BufferedReader(new InputStreamReader(stream))
  private var tokenizer: StringTokenizer = new StringTokenizer(reader.readLine())
  def next(): String = {
    while (!tokenizer.hasMoreTokens()) {
      tokenizer = new StringTokenizer(reader.readLine())
    }
    tokenizer.nextToken()
  }
}
