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 PHP7 (7.0.15) (judge verdict: Time Limit Exceeded)

<?php

fscanf(STDIN, "%d", $n);

$data = explode(" ", trim(fgets(STDIN)));

$count = count($data);
sort($data);

$separator = search($count);

$positive = [];
$negative = [];
for($i=0; $i<$count; $i++){
    if($i < $separator){
        $negative[] = $data[$i];
    }else{
        $positive[] = $data[$i];
    }
}
$p_count = count($positive);
$n_count = count($negative);
while($n--){

    if($n >= 2){

        if($p_count > 0){
            if($n_count>0) {
                if ($p_count > $n_count) {

                    $ans[] = $negative[0]. " ".$positive[$p_count - 1];

                    $negative[] = $negative[0] - $positive[$p_count - 1];
                    unset($positive[$p_count - 1]);
                    unset($negative[0]);
                    $p_count--;
                    sort($negative);
                }else{
                    $ans[] = $positive[$p_count-1]." ". $negative[0];
                    $positive[] = $positive[$p_count-1] - $negative[0];
                    unset($positive[$p_count - 1]);
                    sort($positive);
                    unset($negative[0]);
                    $n_count--;
                    if($n_count> 0){
                        sort($negative);
                    }
                }
            }else{
                $ans[] =$positive[0] ." " .$positive[$p_count - 1];
                $negative[] = $positive[0] - $positive[$p_count - 1] ;
                unset($positive[0]);
                unset($positive[$p_count-1]);
                $p_count--;
                $p_count--;
                $n_count++;
                sort($positive);

                sort($negative);
            }
        }else{
            $ans[] =$negative[$n_count - 1] . " " . $negative[0];
            $positive[] = $negative[$n_count - 1] - $negative[0];
            $n_count= $n_count- 2;
            $p_count++;
            unset($negative[0]);
            unset($negative[$n_count-1]);
            sort($negative);
            sort($positive);

        }
    }else{
        if($p_count == 1){
            $ans[] = $positive[0] ." ". $negative[0];
            echo $positive[0] - $negative[0].PHP_EOL;
        }elseif($p_count == 2){
            $ans[] = $positive[1] ." ". $positive[0];
            echo $positive[1]- $positive[0].PHP_EOL;
        }else{
            $ans[] = $negative[1] ." ". $negative[0];
            echo $negative[1]- $negative[0].PHP_EOL;
        }

        foreach($ans as $value){
            echo $value.PHP_EOL;
        }
        exit;
    }
}




function search($count){
    global $data;
    $start = (int)($count/2);
    $lastmove = $start;
    while(true) {
        if ($start <= 1) {

            if ($data[0] < 0) {
                return (1);
            } else {
                return (0);
            }
        }

        if ($data[$start] > 0) {
            if ($data[$start - 1] <= 0) {
                return ($start);
            } else {
                $lastmove = (int)($lastmove / 2);
                $start = (int)($start - $lastmove);

            }
        }elseif($start +1 == $count){
            return($count);
        }elseif($data[$start] <= 0){
            if($data[$start+1] >= 0){
                return ($start + 1);
            }else{
                $lastmove = (int)($lastmove / 2);
                $start = $start + $lastmove;
            }
        }
    }

}