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: # coding: utf-8
  import sys
  
  
  def solve(a, begin, end, queue):
      #print(begin, end)
      if begin >= end:
          return
      if end - begin == 1:
          return
      maxx = sorted(list(map(abs, a[begin:end + 1])), reverse=True)[0]
      if maxx in a:
          m = a.index(maxx)
      else:
          m = a.index(-1 * maxx)
          maxx = -1 * maxx
      if maxx == 0:
          return []
      if maxx > 0:
          solve(a, begin, m - 1, queue)
          for i in range(max(0, m - 1), end):
              if a[i + 1] >= a[i]:
                  continue
              else:
                  a[i + 1] += a[i]
                  queue.append((i, i + 1))
                  if a[i + 1] < a[i]:
                      a[i + 1] += a[i]
                      queue.append((i, i + 1))
          return queue
      if maxx < 0:
          solve(a, m + 1, end, queue)
          for i in reversed(range(begin, min(len(a) - 1, m + 1))):
              if a[i] <= a[i + 1]:
                  continue
              else:
                  a[i] += a[i + 1]
                  queue.append((i + 1, i))
                  if a[i] > a[i + 1]:
                      a[i] += a[i + 1]
                      queue.append((i + 1, i))
          return queue
  
  
  if __name__ == '__main__':
      n = int(input())
      a = list(map(int, input().split()))
      queue = solve(a, 0, len(a) - 1, [])
      print(len(queue))
      for i in range(len(queue)):
          print(queue[i][0] + 1, queue[i][1] + 1)
      for i in range(len(a)):
          #print(i, a[i])
  
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."}]