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 Ruby (2.3.3) (judge verdict: Runtime Error)

def ascan; gets.split.map(&:to_i);end

n = gets.to_i
aa = ascan

@man = []

def ok?(aa)
    yes = true
    last = aa[0]
    aa[1..-1].each do |e|
        yes &= last <= e
        last = e
    end
    yes
end

def dfs(aa, offset = 0)
    #p aa
    return aa if aa.empty? || ok?(aa)
    
    ix = aa.index(aa.max_by{|a| a.abs})
    x = aa[ix]
    
    if x > 0
        if ix != 0
            a2 = dfs(aa[0...ix], offset)
            a2.size.times{|i| aa[i] = a2[i]}
            if aa[ix-1] > aa[ix]
                ix -= 1
            end
        end
        #p [aa,ix]
        
        i = ix
        while i < aa.size-1
            while aa[i+1] < aa[i]
                aa[i+1] += aa[i]
                @man << [i+offset, i+offset+1]
            end
            i += 1
        end
        ix = aa.index(aa.max_by{|a| a.abs})
        #p [aa,ix]
        dfs(aa[(ix+1)...-1], offset + ix + 1)
        
    elsif x < 0
        if ix != aa.size-1
            a2 = dfs(aa[(ix+1)...-1], offset + ix + 1)
            a2.size.times{|i| aa[-i-1] = a2[-i-1]}
            if aa[ix+1] < aa[ix]
                ix += 1
            end
        end
        #p [aa,ix]
        
        i = ix
        while 0 < i
            while aa[i-1] > aa[i]
                aa[i-1] += aa[i]
                @man << [i+offset, i+offset-1]
            end
            i -= 1
        end
        ix = aa.index(aa.max_by{|a| a.abs})
        #p [aa,ix]
        dfs(aa[0...ix], offset)
    end
    aa
end

    #aa = (1..6).map{rand(1..10)}; @man.clear
    
    _aa = aa.clone
    _aaa = aa.clone
    dfs(aa.clone)
    
    @man.each do |q|
        x,y = q
        _aa[y]+=_aa[x]
    end
    #p _aa
    
    unless ok?(_aa)
        puts _aaa*" "
        p @man
        abort
    end
    
    
abort unless ok?(_aa)

puts @man.size
puts @man.map{|x,y| "#{x+1} #{y+1}"}*"\n"