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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.util.Scanner;

public class Main{
  static int pivot(int[] a,int i,int j){
    int k=i+1;
    while(k<=j && a[i]==a[k]) k++;
    if(k>j) return -1;
    if(a[i]>=a[k]) return i;
    return k;
  }

  static int partition(int[] a,int i,int j,int x){
    int l=i,r=j;

    while(l<=r){

      while(l<=j && a[l]<x)  l++;

      while(r>=i && a[r]>=x) r--;

      if(l>r) break;
      int t=a[l];
      a[l]=a[r];
      a[r]=t;
      l++; r--;
    }
    return l;
  }

  public static void quickSort(int[] a,int i,int j){
    if(i==j) return;
    int p=pivot(a,i,j);
    if(p!=-1){
      int k=partition(a,i,j,a[p]);
      quickSort(a,i,k-1);
      quickSort(a,k,j);
    }
  }

  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int n=scanner.nextInt();
    int a[]=new int[n];
    int flg=0;
    int cmd=0;
    long ans=0;
    //HashMap<Integer,Integer> num=new HashMap<Integer,Integer>();
    long x[]=new long[n];
    long y[]=new long[n];
    int cnt=0;

    for(int i=0;i<n;i++){
      a[i]=scanner.nextInt();
    }

    quickSort(a,0,a.length-1);

    for(int i=0;i<n-1;i++){
      if(a[i]<=0&&a[i+1]>0){
        flg=1;
        cmd=i;
      }
    }
    if(n==2&&a[0]==0){
      x[0]=a[1];
      y[0]=a[0];
      ans=a[1]-a[0];
    }
    else if(flg==1){
      x[cnt]=a[cmd];
      y[cnt]=a[cmd+1];
      cnt++;
      ans=a[cmd]-a[cmd+1];
      for(int i=cmd+2;i<n-1;i++){
        x[cnt]=ans;
        y[cnt]=a[i];
        cnt++;
        //System.out.println(ans+" "+a[i]);
        ans=ans-a[i];
      }
      //System.out.println(a[n-1]+" "+ans);
      x[cnt]=a[n-1];
      y[cnt]=ans;
      cnt++;
      ans=a[n-1]-ans;
      for(int i=0;i<cmd;i++){
        x[cnt]=ans;
        y[cnt]=a[i];
        cnt++;
        //System.out.println(ans+" "+a[i]);
        ans=ans-a[i];
      }
    }
    else{
      if(a[0]<0){
        for(int i=0;i<n/2;i++){
          int tmp=a[i];
          a[i]=a[n-1-i];
          a[n-1-i]=tmp;
        }

        ans=a[0];
        for(int i=1;i<n-1;i++){
          x[cnt]=ans;
          y[cnt]=a[i];
          cnt++;
          ans=ans-a[i];
        }
        x[cnt]=ans;
        y[cnt]=a[n-1];
        cnt++;
        ans=ans-a[n-1];

      }
      else{
        ans=a[0];
        for(int i=1;i<n-1;i++){
          x[cnt]=ans;
          y[cnt]=a[i];
          cnt++;
          ans=ans-a[i];
        }
        x[cnt]=a[n-1];
        y[cnt]=ans;
        cnt++;
        ans=a[n-1]-ans;
      }
    }

    System.out.println(ans);

    for(int i=0;i<n-1;i++){
      System.out.println(x[i]+" "+y[i]);
    }
  }
}