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: Accepted)

#include"bits/stdc++.h"
#include<boost/multi_array.hpp>
#include<boost/optional.hpp>
#include<boost/range/irange.hpp>
#include<boost/range/algorithm.hpp>
#include<boost/range/adaptor/reversed.hpp>
#include<boost/operators.hpp>
#include<boost/dynamic_bitset.hpp>
namespace adaptor = boost::adaptors;
template<class T>using p_queue = std::priority_queue<T, std::vector<T>, std::greater<>>;

void Main()
{
	std::size_t N;
	std::cin >> N;
	std::multiset<int> set;
	std::size_t minus_count = 0;
	for (int i : boost::irange<std::size_t>(0, N))
	{
		int a;
		std::cin >> a;
		if (a < 0)
		{
			++minus_count;
		}
		set.emplace(a);
	}
	std::vector<std::pair<int, int>> action;
	if (minus_count == N)
	{
		while (set.size() != 1)
		{
			auto a = *set.rbegin();
			auto b = *std::next(set.rbegin());
			set.erase(std::prev(set.end(), 2), set.end());
			action.emplace_back(a, b);
			set.emplace(a - b);
		}
	}
	else if (minus_count == 0)
	{
		while (set.size() != 2)
		{
			auto a = *set.begin();
			auto b = *std::next(set.begin());
			set.erase(set.begin(), std::next(set.begin(), 2));
			action.emplace_back(a, b);
			set.emplace(a - b);
		}
		auto a = *set.begin();
		auto b = *std::next(set.begin());
		set.erase(set.begin(), std::next(set.begin(), 2));
		action.emplace_back(b, a);
		set.emplace(b - a);
	}
	else
	{
		while (minus_count != 1)
		{
			auto ite = set.lower_bound(0);
			auto a = *set.begin();
			auto b = *ite;
			set.erase(ite);
			set.erase(set.begin());
			action.emplace_back(b, a);
			set.emplace(b - a);
			--minus_count;
		}
		while (set.size() != 2)
		{
			auto a = *set.begin();
			auto b = *std::next(set.begin());
			set.erase(set.begin(), std::next(set.begin(), 2));
			action.emplace_back(a, b);
			set.emplace(a - b);
		}
		auto a = *set.begin();
		auto b = *std::next(set.begin());
		set.erase(set.begin(), std::next(set.begin(), 2));
		action.emplace_back(b, a);
		set.emplace(b - a);
	}
	std::cout << *set.begin() << std::endl;
	for (auto&& p : action)
	{
		std::cout << p.first << " " << p.second << std::endl;
	}
}

int main()
{
	std::cin.tie(nullptr);
	std::ios_base::sync_with_stdio(false);
	std::cout << std::fixed << std::setprecision(15);
	Main();
}