Problem:
Score : 600 points

Problem 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}

Constraints

2 \leq N \leq 50

-10^{6} \leq a_i \leq 10^{6}

All input values are integers.

Input

Input is given from Standard Input in the following format:

N
a_1 a_2 ... a_{N}

Output

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.

Sample Input 1

3
-2 5 -1

Sample Output 1

2
2 3
3 3

After the first operation, a = (-2,5,4).

After the second operation, a = (-2,5,8), and the condition is now satisfied.

Sample Input 2

2
-1 -3

Sample Output 2

1
2 1

After the first operation, a = (-4,-3) and the condition is now satisfied.

Sample Input 3

5
0 0 0 0 0

Sample Output 3

0

The condition is satisfied already in the beginning.

Solution in PyPy3 (2.4.0) (judge verdict: Runtime Error)

import sys,queue,math,copy,itertools,bisect,collections,heapq

def main():
    sys.setrecursionlimit(10**7)
    INF = 10**7
    MOD = 10**9 + 7
    LI = lambda : [int(x) for x in sys.stdin.readline().split()]
    NI = lambda : int(sys.stdin.readline())
    SI = lambda : sys.stdin.readline().rstrip()

    N = NI()
    A = [0] + LI()
    ans = []
    x = []
    xn = []

    def make_x(x,xn,p):
        for i in range(N+1):
            for j in range(N+1):
                if j == p:
                    x.append((A[i]*2+A[j],i,j))
                    xn.append(A[i]*2+A[j])
                else:
                    x.append((A[i]+A[j],i,j))
                    xn.append(A[i]+A[j])

        x.sort()
        xn.sort()

    for i in range(2,N+1):
        if A[i-1] > A[i]:
            y = False
            make_x(x,xn,i-1)
            j = bisect.bisect(xn,A[i]-A[i-1])
            if i > 2:
                if A[i-2] > A[i-1] + xn[j-1]:
                    y = True
            if y == False:
                if j > 0 and i == 2:
                    for k in x[j-1][1:]:
                        if k > 0:
                            ans.append((k,i-1))
                        A[i-1] += xn[j-1]
                else:
                    y = True
            if y:
                make_x(x,xn,i)
                j = bisect.bisect_left(xn,A[i-1]-A[i])
                for k in x[j][1:]:
                    if k > 0: ans.append((k,i))
                A[i] += xn[j]

    print(len(ans))
    for x in ans:
        print(x[0],x[1])

if __name__ == '__main__':
    main()