Problem:
Score : 500 points

Problem Statement

There are N integers, A_1, A_2, ..., A_N, written on a blackboard.

We will repeat the following operation N-1 times so that we have only one integer on the blackboard.

Choose two integers x and y on the blackboard and erase these two integers. Then, write a new integer x-y.

Find the maximum possible value of the final integer on the blackboard and a sequence of operations that maximizes the final integer.

Constraints

2 \leq N \leq 10^5

-10^4 \leq A_i \leq 10^4

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the maximum possible value M of the final integer on the blackboard, and a sequence of operations x_i, y_i that maximizes the final integer, in the format below.

Here x_i and y_i represent the integers x and y chosen in the i-th operation, respectively.

If there are multiple sequences of operations that maximize the final integer, any of them will be accepted.

M
x_1 y_1
:
x_{N-1} y_{N-1}

Sample Input 1

3
1 -1 2

Sample Output 1

4
-1 1
2 -2

If we choose x = -1 and y = 1 in the first operation, the set of integers written on the blackboard becomes (-2, 2).

Then, if we choose x = 2 and y = -2 in the second operation, the set of integers written on the blackboard becomes (4).

In this case, we have 4 as the final integer. We cannot end with a greater integer, so the answer is 4.

Sample Input 2

3
1 1 1

Sample Output 2

1
1 1
1 0

Solution in Scala (2.11.7) (judge verdict: Runtime Error)

import java.util.Scanner

import scala.collection.mutable.ArrayBuffer


object Main {

  case class Point(x: Long, y: Long) {
    def +(that: Point) = Point(this.x + that.x, this.y + that.y)

    def -(that: Point) = Point(this.x - that.x, this.y - that.y)
  }

  def read() = {
    val sc = new Scanner(System.in)
    val n = sc.nextInt()
    val a = IndexedSeq.fill(n)(sc.nextLong())
    (n, a)
  }


  def read2() = {
    val input = io.Source.stdin.getLines()
    val n = input.next().toInt
    val a = input.next().split(" ").map(_.toLong)
    (n, a)
  }

  case class Result(m: Long, ps: IndexedSeq[Point])

  def output(result: Result) = {
    val out = new java.io.PrintWriter(System.out)
    out.println(result.m)
    result.ps.foreach(p => out.println(s"${p.x} ${p.y}"))
    out.flush()
  }


  def solve(n: Int, a: IndexedSeq[Long]): Result = {
    val reverseList = {
      val nNegative = a.count(ai => ai < 0)
      // nNevative: 反転させたい個数
      if (nNegative == 0) {
        // 一番小さいのを1つ反転
        val minIdx = (0 until n).minBy(i => a(i))
        IndexedSeq.tabulate(n)(i => if (i == minIdx) true else false)
      } else {
        a.map(ai => ai < 0)
      }
    }
    val resultMax = (0 until n).map(i => if (reverseList(i)) -a(i) else a(i)).sum
    val opeList = ArrayBuffer.empty[Point]

    val reverseQueue: java.util.Queue[Long] = new java.util.ArrayDeque[Long]()
    val nonReverseQueue: java.util.Queue[Long] = new java.util.ArrayDeque[Long]()
    var reverseQueueSize = 0 // sizeの計算量がわからない
    var nonReverseQueueSize = 0
    var isReverseMode = false
    var midStateNum = resultMax
    reverseQueue.size
    for (i <- 0 until n) {
      if (reverseList(i)) {
        reverseQueue.add(a(i))
        reverseQueueSize += 1
      } else {
        nonReverseQueue.add(a(i))
        nonReverseQueueSize += 1
      }
    }

    for (_ <- 0 until n - 2) {
      //println(s"$midStateNum, ($nonReverseQueueSize, $reverseQueueSize), $isReverseMode")
      if (isReverseMode) {
        if (nonReverseQueueSize != 1) {
          // (midStateNum + next) - next
          val next = nonReverseQueue.remove()
          nonReverseQueueSize -= 1
          opeList.append(Point(midStateNum + next, next))
          midStateNum = midStateNum + next
        } else {
          // next - (-midStateNum + next)
          val next = reverseQueue.remove()
          reverseQueueSize -= 1
          opeList.append(Point(next, -midStateNum + next))
          isReverseMode = !isReverseMode
          midStateNum = -midStateNum + next
        }
      } else {
        if (reverseQueueSize != 1) {
          // (midStateNum + next) - next
          val next = reverseQueue.remove()
          reverseQueueSize -= 1
          opeList.append(Point(midStateNum + next, next))
          midStateNum = midStateNum + next
        } else {
          // next - (-midStateNum + next)
          val next = nonReverseQueue.remove()
          nonReverseQueueSize -= 1
          opeList.append(Point(next, -midStateNum + next))
          midStateNum = -midStateNum + next
          isReverseMode = !isReverseMode

        }
      }
    }
    if (isReverseMode) {
      opeList.append(Point(reverseQueue.remove(), nonReverseQueue.remove()))
    } else {
      opeList.append(Point(nonReverseQueue.remove(), reverseQueue.remove()))
    }

    assert(opeList.length == n - 1)

    Result(resultMax, opeList.reverse.toIndexedSeq)
  }

  def main(args: Array[String]): Unit = {
    val (n, a) = read2()
    output(solve(n, a))
  }
}