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}

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}

Examples

Input

3
1 -1 2


Output

4
-1 1
2 -2


Input

3
1 1 1


Output

1
1 1
1 0
#!/usr/bin/env python
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

import random
import collections
import math
import itertools

def real_main():
    N = read_int()
    nums = read_int_array()
    x, actions = solve(N, nums)
    print(x)
    for a, b in actions:
        print(a, b)


def solve1(n, nums):
    next_small = n // 2 - 1
    next_big = next_small + 1
    next_op = n % 2

    actions = []
    if next_op:
        last = nums[next_small] - nums[next_big]
        actions.append((nums[next_small], nums[next_big]))
    else:
        last = nums[next_big] - nums[next_small]
        actions.append((nums[next_big], nums[next_small]))

    next_big += 1
    next_small -= 1

    next_op = 1 - next_op
    while next_small >= 0 or next_big < n:
        if next_op:
            actions.append((nums[next_small], last))
            last = nums[next_small] - last
            next_small -= 1
        else:
            actions.append((nums[next_big], last))
            last = nums[next_big] - last
            next_big += 1
        next_op = 1 - next_op

    return last, actions

def solve2(n, nums):
    next_small = (n+1) // 2 - 1
    next_big = next_small + 1
    next_op = n % 2

    actions = []
    if next_op: # maximize
        last = nums[next_big] - nums[next_small]
        #actions.append((nums[next_small], nums[next_big]))
    else: # minimize
        last = nums[next_small] - nums[next_big]
        #actions.append((nums[next_big], nums[next_small]))

    next_big += 1
    next_small -= 1

    next_op = 1 - next_op
    while next_small >= 0 or next_big < n:
        if next_op:
            actions.append((nums[next_big], last))
            last = last - nums[next_big]
            next_big += 1
        else:
            actions.append((nums[next_small], last))
            last = last - nums[next_small]
            next_small -= 1
        next_op = 1 - next_op

    return last, actions

def solve(n, nums):
    nums.sort()
    actions = []
    if nums[0] <= 0 <= nums[-1]:
        ans = nums[0]
        ans2 = nums[-1]
        for i in range(1, n-1):
            if nums[i] > 0:
                actions.append((ans, nums[i]))
                ans -= nums[i]
            else:
                actions.append((ans2, nums[i]))
                ans2 -= nums[i]
        actions.append((ans2, ans))
        ans = ans2 - ans
    elif nums[-1] < 0:
        ans = nums[-1]
        for i in range(n-1):
            actions.append((ans, nums[i]))
            ans -= nums[i]
    else:
        ans = nums[0]
        for i in range(1, n-1):
            actions.append((ans, nums[i]))
            ans -= nums[i]
        actions.append((nums[-1], ans))
        ans = nums[-1] - ans
    return ans, actions


def solveSlow(n, nums):

    def maximize(nums):
        if len(nums) == 2:
            return max(nums[0] - nums[1], nums[1] - nums[0])
        nums.sort()
        return max(nums[-1] - minimize(nums[:-1]), maximize(nums[1:]) - nums[0])

    def minimize(nums):
        if len(nums) == 2:
            return min(nums[0] - nums[1], nums[1] - nums[0])
        nums.sort()
        return min(minimize(nums[:-1]) - nums[-1], nums[0] - maximize(nums[1:]))

    return maximize(nums)


def main():
    if 'PYCHARM_HOSTED' in os.environ:
        main_pycharm()
    else:
        real_main()


def generate_nums(n, min, max, check_if_good=None):
    while True:
        nums = [random.randint(min, max) for _ in range(n)]
        if check_if_good is None or check_if_good(nums):
            return nums


from copy import deepcopy
def main_pycharm():
    solution = solve

    test_inputs = []
    for _ in range(100):
        n = random.randint(2, 10)
        test_inputs.append([n, generate_nums(n, -100, 100)])
        test_inputs[-1][1].sort()


    test_outputs = None
    judge = None
    slow_solution = solveSlow
    if solution is not None:
        if test_outputs is not None:
            test_with_answers(solution, test_inputs, test_outputs)
        if judge is not None:
            test_with_judge(solution, test_inputs, judge)
        if slow_solution is not None:
            test_with_slow_solution(solution, test_inputs, slow_solution)


def test_with_answers(solution, inputs_answers):
    total, wrong = 0, 0
    for args, test_ans in inputs_answers:
        ans = solution(*args.copy())
        if ans != test_ans:
            print('WRONG! ans=%s, test_ans=%s, args=%s' % (ans, test_ans, args))
            wrong += 1
        else:
            print('GOOD')
        total += 1
    print('ALL %d TESTS PASSED' % total if not wrong else '%d out of %d tests are WRONG' % (wrong, total))


def test_with_judge(solution, inputs_gen, judge):
    total, wrong = 0, 0
    for args in inputs_gen:
        ans = solution(*deepcopy(args))
        if not judge(deepcopy(ans), *deepcopy(args)):
            print('WRONG! ans=%s, args=%s' % (ans, args))
            wrong += 1
        total += 1
    print('ALL %d TESTS PASSED' % total if not wrong else '%d out of %d tests are WRONG' % (wrong, total))


def test_with_slow_solution(solution, inputs_gen, solution_slow):
    total, wrong = 0, 0
    for args in inputs_gen:
        ans = solution(*deepcopy(args))[0]
        slow = solution_slow(*deepcopy(args))
        if ans != slow:
            print('WRONG! ans=%s, slow=%s, args=%s' % (ans, slow, args))
            wrong += 1
        total += 1
    print('ALL %d TESTS PASSED' % total if not wrong else '%d out of %d tests are WRONG' % (wrong, total))


# region fastio

BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")

read = input
read_int = lambda: int(input())
read_array = lambda sep=None, maxsplit=-1: input().split(sep, maxsplit)
read_int_array = lambda: [int(a) for a in read_array()]

# endregion

if __name__ == "__main__":
    main()
