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 Rust (1.42.0) (judge verdict: Accepted)

use proconio::{
   fastout, input,
   marker::{Bytes, Chars, Isize1, Usize1},
};

use std::collections::BinaryHeap;

#[fastout]
fn main() {
   input! {
      n:usize,
      a:[isize;n]
   }
   let mut flag = vec![true; n];
   let mut ans = 0;
   let mut out = vec![];
   let mut max = BinaryHeap::new();
   let mut min = BinaryHeap::new();
   for (i, x) in a.iter().enumerate() {
      max.push((*x, i));
      min.push((-1 * *x, i));
   }
   for t in 0..n - 1 {
      let (max_value, min_value);
      loop {
         let (x, i) = max.pop().unwrap();
         if flag[i] {
            max_value = x;
            flag[i] = false;
            break;
         }
      }
      loop {
         let (x, i) = min.pop().unwrap();
         if flag[i] {
            min_value = -1 * x;
            flag[i] = false;
            break;
         }
      }

      if t == n - 2 {
         out.push((max_value, min_value));
         ans = max_value - min_value;
      } else {
         let next_max = max.peek().unwrap().0;
         let next_min = min.peek().unwrap().0;
         if next_max == -1 * next_min {
            if next_max > 0 {
               out.push((min_value, max_value));
               max.push((min_value - max_value, flag.len()));
               min.push((-1 * (min_value - max_value), flag.len()));
               flag.push(true);
            } else {
               out.push((max_value, min_value));
               max.push((max_value - min_value, flag.len()));
               min.push((-1 * (max_value - min_value), flag.len()));
               flag.push(true);
            }
         } else if next_max.abs() > next_min.abs() {
            out.push((min_value, max_value));
            max.push((min_value - max_value, flag.len()));
            min.push((-1 * (min_value - max_value), flag.len()));
            flag.push(true);
         } else {
            out.push((max_value, min_value));
            max.push((max_value - min_value, flag.len()));
            min.push((-1 * (max_value - min_value), flag.len()));
            flag.push(true);
         }
      }
   }
   println!("{}", ans);
   for i in out {
      println!("{} {}", i.0, i.1);
   }
}