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
INF = 10 ** 100


def solve(ns):
    n = len(ns)
    ns.sort(reverse=True)
    pos = ns[:(n + 1) / 2]
    neg = ns[(n + 1) / 2:]

    while len(pos) > 1 and pos[-1] < 0:
        neg.append(pos.pop())

    neg.sort()
    while len(neg) > 1 and neg[-1] > 0:
        pos.append(neg.pop())

    ans = sum(pos) - sum(neg)
    print ans

    #print pos, neg

    res = INF
    while pos and neg:
        if len(pos) >= 2 and len(neg) >= 2:
            a1, a2 = pos.pop(), pos.pop()
            b1, b2 = neg.pop(), neg.pop()

            c1 = a1 - b1
            print a1, b1

            c2 = b2 - a2
            print b2, a2

            pos.append(c1)
            neg.append(c2)
        elif len(pos) == 1 and len(neg) == 1:
            a1 = pos.pop()
            b1 = neg.pop()
            c = a1 - b1
            print a1, b1

            res = c
        elif len(neg) == 1:
            assert pos
            a1 = pos.pop()
            b1 = neg.pop()

            c = b1 - a1
            print b1, a1

            if not pos and not neg:
                res = c
            else:
                neg.append(c)
        elif len(pos) == 1:
            assert neg
            a1 = pos.pop()
            b1 = neg.pop()

            c = a1 - b1
            print a1, b1

            if not pos and not neg:
                res = c
            else:
                pos.append(c)
        else:
            print pos, neg
            assert False
    assert res == ans
    assert not pos
    assert not neg
    return res

#assert solve([1, -1]) == 2
#assert solve([1, -1, -5]) == 7
#assert solve([1, -1, 3, 4]) == 9

n = int(raw_input())
ns = map(int, raw_input().split())
solve(ns)

