package main

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

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

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

	dp := make([]int64, n+1)
	typ := make([]int, n)
	end := make([]int, n)

	for i := n - 1; i >= 0; i-- {
		best := int64(a[i]) + dp[i+1]
		typ[i] = 0
		end[i] = i
		for j := i; j < n; j++ {
			l := j - i + 1
			val := int64(l*l) + dp[j+1]
			if val > best {
				best = val
				typ[i] = 1
				end[i] = j
			}
		}
		dp[i] = best
	}

	segs := make([][2]int, 0)
	for i := 0; i < n; {
		if typ[i] == 1 {
			segs = append(segs, [2]int{i, end[i]})
			i = end[i] + 1
		} else {
			i++
		}
	}

	cur := make([]int, n)
	copy(cur, a)
	ops := make([][2]int, 0)

	apply := func(l, r int) {
		var seen [25]bool
		for i := l; i <= r; i++ {
			if cur[i] >= 0 && cur[i] < len(seen) {
				seen[cur[i]] = true
			}
		}
		mex := 0
		for seen[mex] {
			mex++
		}
		for i := l; i <= r; i++ {
			cur[i] = mex
		}
		ops = append(ops, [2]int{l + 1, r + 1})
	}

	ensureZero := func(pos int) {
		if cur[pos] != 0 {
			apply(pos, pos)
		}
	}

	ensureNonEqual := func(pos, t int) {
		if cur[pos] == t {
			apply(pos, pos)
		}
	}

	var buildPerm func(int, int)
	var makeConstPrev func(int, int)
	var makeMax func(int, int)

	makeConstPrev = func(l, r int) {
		buildPerm(l, r-1)
		target := r - l
		ensureNonEqual(r, target)
		apply(l, r)
	}

	buildPerm = func(l, r int) {
		if l == r {
			ensureZero(l)
			return
		}
		makeConstPrev(l, r)
		buildPerm(l, r-1)
	}

	makeMax = func(l, r int) {
		buildPerm(l, r)
		apply(l, r)
	}

	for _, seg := range segs {
		makeMax(seg[0], seg[1])
	}

	fmt.Fprintln(out, dp[0], len(ops))
	for _, op := range ops {
		fmt.Fprintln(out, op[0], op[1])
	}
}