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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>

using namespace std;
using ll = long long;

constexpr ll infl = 10000000000000000LL;
constexpr int inf = 1000000000;

int main() {
    int n;
    cin >> n;
    vector<int> positive, negative, zero;
    int pmin = inf, nmin = -inf;
    for (int i = 0; i < n; ++i) {
        int a;
        cin >> a;
        if (a > 0) {
            if (a < pmin)
                pmin = a;
            positive.push_back(a);
        }
        else if (a < 0) {
            if (-a < -nmin)
                nmin = a;
            negative.push_back(a);
        }
        else
            zero.push_back(a);
    }

    int m = 0;
    vector<pair<int, int>> ans;
    if (positive.size() == 0) {
        if (zero.size()) nmin = 0;
        negative.insert(negative.end(), zero.begin(), zero.end());
        bool skip = false;
        m = nmin;
        for (int k : negative) {
            if (k == nmin) {
                if (skip) {
                    ans.push_back({nmin, k});
                    m += abs(k);
                } else {
                    skip = true;
                }
            }
            else {
                ans.push_back({nmin, k});
                m += abs(k);
            }
        }
    } else if (negative.size() == 0) {
        bool first = true;
        bool skip = false;
        int felem;
        if (zero.size()) pmin = 0;
        positive.insert(positive.end(), zero.begin(), zero.end());
        m = -pmin;
        for (int k : positive) {
            if (k == pmin) {
                if (skip) {
                    if (first) {
                        felem = k;
                        first = false;
                    }
                    else {
                    ans.push_back({pmin, k});
                    m += abs(k);
                    }
                } else {
                    skip = true;
                }
            }
            else {
                if (first) {
                    felem = k;
                    first = false;
                } else {
                    ans.push_back({pmin, k});
                    m += abs(k);
                }
            }
        }

        ans.push_back({felem, -m});
        m += felem;
    } else {
        m = positive[0];
        for (int i = 1; i < positive.size(); ++i) {
            ans.push_back({negative[0], positive[i]});
            negative[0] -= positive[i];
        }

        for (int i = 0; i < negative.size(); ++i) {
            ans.push_back({m, negative[i]});
            m += -negative[i];
        }

        for (int i = 0; i < zero.size(); ++i) {
            ans.push_back({m, 0});
        }
    }

    cout << m << endl;
    for (auto x : ans) {
        cout << x.first << " " << x.second<< endl;
    }

    return 0;
}