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 Ruby (2.3.3) (judge verdict: Time Limit Exceeded)

# https://github.com/tompng/no_sltd/blob/master/lib/no_sltd.rb
module NoSLTD
  THREAD_LOCAL_KEY = :no_sltd_stack_level
  def self.recursive
    level = (Thread.current[THREAD_LOCAL_KEY] || 0)
    Thread.current[THREAD_LOCAL_KEY] = level + 1
    out = level < 64 ? yield : Fiber.new { yield }.resume
    Thread.current[THREAD_LOCAL_KEY] = level
    out
  end
end

def no_sltd method_or_proc=nil, &block
  raise '`no_sltd def func end`, `block = no_sltd -> {}` or `no_sltd { block.call }`' unless block_given? ^ !!method_or_proc
  if block_given?
    NoSLTD.recursive(&block)
  elsif Proc === method_or_proc
    lambda do |*a, &b|
      NoSLTD.recursive { method_or_proc.call(*a, &b) }
    end
  else
    receiver = respond_to?(:instance_method) ? self : self.class
    original = receiver.instance_method method_or_proc
    receiver.send :remove_method, method_or_proc
    receiver.send :define_method, method_or_proc do |*a, &b|
      NoSLTD.recursive { original.bind(self).call(*a, &b) }
    end
  end
end


Node = Struct.new(:leaf, :value, :left, :right)

def make_leaf
    Node.new(true)
end

def make_branch(left, right)
  Node.new(false, nil, left, right)
end

def count(nminus)
    res = 0
    @N.times {|i|
        if (i < nminus)
          res -= @As[i];
        else
          res += @As[i];
        end
    }
    return res;
end

no_sltd def make_tree(a, b)
  if (a + b == 1)
      if (a == 1)
        return make_leaf();
      else
        printf("tukurenai\n"); exit(1);
      end
  else
      x = 1
      z = 1
      y = b - z;
      w = a - x;
      return make_branch(make_tree(x, y), make_tree(z, w));
  end
end

@used_plus = 0;
@used_minus = 0;

no_sltd def f(node, minus)
  if (node.leaf)
    if (minus)
      node.value = @As[@used_minus]
      @used_minus += 1
    else
      node.value = @As[@N - 1 - @used_plus]
      @used_plus += 1
    end
  else
    f(node.left, minus);
    f(node.right, !minus);
  end
end

no_sltd def g(node)
  if (node.leaf)
      return node.value;
  else
    x = g(node.left);
    y = g(node.right);
    puts "#{x} #{y}"
    return x - y;
  end
end

def show(nminus)
  nplus = @N - nminus;
  node = make_tree(@N - nminus, nminus);
  f(node, false);
  res = g(node);
end

def main()
  @N = gets.to_i
  @As = gets.split(" ").map(&:to_i)
  @As.sort!
  best = 0;
  @N.times {|i|
    best = i  if (@As[i] < 0)
  }
  m = -1
  argmax = 0
  (-1..1).each {|i|
    j = [[best + i, 1].max, @N - 1].min
    c = count(j)
    if c > m
      m = c
      argmax = j
    end
  }
  puts m
  show argmax
end
main