```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n int
	fmt.Fscan(reader, &n)

	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &a[i])
	}

	// Compute difference array
	// d[i] = a[i] - a[i-1], with a[0] = 0
	// Positive differences mean we need to start new segments
	// We collect segments by tracking increases

	type Segment struct {
		l, r int
	}

	var segments []Segment

	// Use a stack-based approach or greedy approach
	// For each position, if a[i] > a[i-1], we need (a[i]-a[i-1]) new segments starting at i
	// If a[i] < a[i-1], we need to close (a[i-1]-a[i]) segments ending at i-1

	// We'll use a priority queue or just track active segments
	// Since we want minimum calls, we greedily extend segments as far as possible

	// Stack approach: maintain a stack of (value, start_position)
	// When current value increases, push new segments
	// When current value decreases, pop segments and record their end

	type stackItem struct {
		val   int
		start int
	}

	stack := []stackItem{}

	for i := 1; i <= n; i++ {
		cur := a[i]
		var prev int
		if len(stack) > 0 {
			prev = stack[len(stack)-1].val
		} else {
			prev = 0
		}

		if cur > prev {
			// Push (cur - prev) segments starting at i
			// We can represent this as one stack item with count
			stack = append(stack, stackItem{cur - prev, i})
		} else if cur < prev {
			// Need to close some segments
			// Close segments until stack total == cur
			remaining := prev - cur
			for remaining > 0 && len(stack) > 0 {
				top := stack[len(stack)-1]
				if top.val <= remaining {
					// Close all of this group
					for k := 0; k < top.val; k++ {
						segments = append(segments, Segment{top.start, i - 1})
					}
					remaining -= top.val
					stack = stack[:len(stack)-1]
				} else {
					// Close 'remaining' of this group
					for k := 0; k < remaining; k++ {
						segments = append(segments, Segment{top.start, i - 1})
					}
					stack[len(stack)-1].val -= remaining
					remaining = 0
				}
			}
		}
	}

	// Close all remaining segments at position n
	for len(stack) > 0 {
		top := stack[len(stack)-1]
		for k := 0; k < top.val; k++ {
			segments = append(segments, Segment{top.start, n})
		}
		stack = stack[:len(stack)-1]
	}

	fmt.Fprintln(writer, len(segments))
	for _, seg := range segments {
		fmt.Fprintf(writer, "%d %d\n", seg.l, seg.r)
	}
}
```