output_description: Let m be the number of operations in your solution. In the first line, print
  m. In the i-th of the subsequent m lines, print the numbers x and y chosen in
  the i-th operation, with a space in between. The output will be considered
  correct if m is between 0 and 2N (inclusive) and a satisfies the condition
  after the m operations.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 ... a_{N}
attempt: ###############################################################################
  
  from sys import stdout
  from bisect import bisect_left as binl
  from copy import copy, deepcopy
  from collections import defaultdict
  import math
  
  
  mod = 1
  
  
  def intin():
      input_tuple = input().split()
      if len(input_tuple) <= 1:
          return int(input_tuple[0])
      return tuple(map(int, input_tuple))
  
  
  def intina():
      return [int(i) for i in input().split()]
  
  
  def intinl(count):
      return [intin() for _ in range(count)]
  
  
  def modadd(x, y):
      global mod
      return (x + y) % mod
  
  
  def modmlt(x, y):
      global mod
      return (x * y) % mod
  
  
  def mod_inv(x):
      # available only when mod is prime
      global mod
      return pow(x, mod - 2, mod)
  
  
  def gcm(x, y):
      while y != 0:
          z = x % y
          x = y
          y = z
      return x
  
  
  def combination(x, y):
      assert x >= y
  
      ret = math.factorial(x)
      ret = ret // (math.factorial(x - y) * math.factorial(y))
  
      return ret
  
  
  def get_divisors(x):
      retlist = []
      for i in range(1, int(x**0.5) + 3):
          if x % i == 0:
              retlist.append(i)
              retlist.append(x // i)
      return retlist
  
  
  def get_factors(x):
      retlist = []
      for i in range(2, int(x**0.5) + 3):
          while x % i == 0:
              retlist.append(i)
              x = x // i
      retlist.append(x)
      return retlist
  
  
  def make_linklist(xylist):
      linklist = {}
      for a, b in xylist:
          linklist.setdefault(a, [])
          linklist.setdefault(b, [])
          linklist[a].append(b)
          linklist[b].append(a)
      return linklist
  
  
  def calc_longest_distance(linklist, v=1):
      distance_list = {}
      distance_count = 0
      distance = 0
      vlist_previous = []
      vlist = [v]
      nodecount = len(linklist)
  
      while distance_count < nodecount:
          vlist_next = []
          for v in vlist:
              distance_list[v] = distance
              distance_count += 1
              vlist_next.extend(linklist[v])
          distance += 1
          vlist_to_del = vlist_previous
          vlist_previous = vlist
          vlist = list(set(vlist_next) - set(vlist_to_del))
  
      max_distance = -1
      max_v = None
      for v, distance in distance_list.items():
          if distance > max_distance:
              max_distance = distance
              max_v = v
  
      return (max_distance, max_v)
  
  
  def calc_tree_diameter(linklist, v=1):
      _, u = calc_longest_distance(linklist, v)
      distance, _ = calc_longest_distance(linklist, u)
      return distance
  
  
  class UnionFind:
  
      def __init__(self, n):
          self.parent = [i for i in range(n)]
  
      def root(self, i):
          if self.parent[i] == i:
              return i
          self.parent[i] = self.root(self.parent[i])
          return self.parent[i]
  
      def unite(self, i, j):
          rooti = self.root(i)
          rootj = self.root(j)
          if rooti == rootj:
              return
          if rooti < rootj:
              self.parent[rootj] = rooti
          else:
              self.parent[rooti] = rootj
  
      def same(self, i, j):
          return self.root(i) == self.root(j)
  
  
  ###############################################################################
  
  
  def main():
      n = intin()
      alist = intina()
  
      absmax = -float("inf")
      absidx = -1
  
      for i, a in enumerate(alist):
          if abs(a) > absmax:
              absmax = abs(a)
              absidx = i
  
      if alist[absidx] == 0:
          print(0)
          return
  
      print(n * 2)
  
      if alist[absidx] > 0:
          for i in range(n):
              print("%d %d" % (absidx + 1, i + 1))
              print("%d %d" % (absidx + 1, i + 1))
              alist[i] += alist[absidx]
              alist[i] += alist[absidx]
              absidx = i
  
      else:
          for i in range(n - 1, -1, -1):
              print("%d %d" % (absidx + 1, i + 1))
              print("%d %d" % (absidx + 1, i + 1))
              alist[i] += alist[absidx]
              alist[i] += alist[absidx]
              absidx = i
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  Snuke has an integer sequence, a, of length N. The i-th element of a
  (1-indexed) is a_{i}.
  
  He can perform the following operation any number of times:
  
    * Operation: Choose integers x and y between 1 and N (inclusive), and add a_x to a_y.
  
  He would like to perform this operation between 0 and 2N times (inclusive) so
  that a satisfies the condition below. Show one such sequence of operations. It
  can be proved that such a sequence of operations always exists under the
  constraints in this problem.
  
    * Condition: a_1 \leq a_2 \leq ... \leq a_{N}
samples: [{"input": "3\n    -2 5 -1", "output": "2\n    2 3\n    3 3\n    \n\n  * After the first operation, a = (-2,5,4).\n  * After the second operation, a = (-2,5,8), and the condition is now satisfied.\n\n* * *"}, {"input": "2\n    -1 -3", "output": "1\n    2 1\n    \n\n  * After the first operation, a = (-4,-3) and the condition is now satisfied.\n\n* * *"}, {"input": "5\n    0 0 0 0 0", "output": "0\n    \n\n  * The condition is satisfied already in the beginning."}]