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.15.1) (judge verdict: Accepted)

#![allow(unused_imports)]
#![allow(unused_macros)]
use std::cmp::{ min, max };

macro_rules! ewriteln {
    ($($args:expr),*) => { let _ = writeln!(&mut std::io::stderr(), $($args),*); };
}
macro_rules! trace {
    ($x:expr) => { ewriteln!(">>> {} = {:?}", stringify!($x), $x) };
    ($($xs:expr),*) => { trace!(($($xs),*)) }
}
macro_rules! put {
    ($x:expr) => { println!("{}", $x) };
    ($x:expr, $($xs:expr),*) => { print!("{} ", $x); put!($($xs),*) }
}

#[allow(dead_code)]
const M: i64 = 1_000_000_007;

fn solve(xs: &[i32], num: usize, negative: bool) -> i32{
    if xs.len() == 2 {
        if !negative {
            println!("{} {}", xs[1], xs[0]);
            xs[1] - xs[0]
        } else {
            println!("{} {}", xs[0], xs[1]);
            xs[0] - xs[1]
        }
    } else {
        if !negative {
            if num > 1 {
                let right = solve(&xs[1..], num - 1, negative);
                println!("{} {}", right, xs[0]);
                right - xs[0]
            } else {
                let left = solve(&xs[0..xs.len() - 1], num, !negative);
                println!("{} {}", xs[xs.len()-1], left);
                xs[xs.len() - 1] - left
            }
        } else {
            if num > 1 {
                let right = solve(&xs[1..], num - 1, !negative);
                println!("{} {}", xs[0], right);
                xs[0] - right
            } else {
                let left = solve(&xs[0..xs.len() - 1], num, negative);
                println!("{} {}", left, xs[xs.len()-1]);
                left - xs[xs.len() - 1]
            }
        }
    }
}

fn main() {
    let mut sc = Scanner::new();
    let n: usize = sc.cin();
    let mut xs: Vec<i32> = (0..n).map(|_| sc.cin()).collect();
    xs.sort();
    let mut num_neg = xs.iter().filter(|&x| *x < 0).count();
    if num_neg == 0 { num_neg = 1; }
    if num_neg == n { num_neg = n - 1; }
    let ans: i32 = (num_neg..n).map(|i| xs[i]).sum::<i32>() - (0..num_neg).map(|i| xs[i]).sum::<i32>();
    put!(ans);
    let _ = solve(&xs[..], num_neg, false);

}

use std::io::{self, Write};
use std::str::FromStr;
use std::collections::VecDeque;

struct Scanner { stdin: io::Stdin, buffer: VecDeque<String>, }
impl Scanner {
    fn new() -> Scanner { Scanner { stdin: io::stdin(), buffer: VecDeque::new() } }
    fn cin<T: FromStr>(&mut self) -> T {
        while self.buffer.len() == 0 {
            let mut line = String::new();
            let _ = self.stdin.read_line(&mut line);
            for w in line.split_whitespace() {
                self.buffer.push_back(String::from(w));
            }
        }
        self.buffer.pop_front().unwrap().parse::<T>().ok().unwrap()
    }
}