```go
package main

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

type Command struct {
	l, r int
}

var n int
var A []int
var ans []Command
var found bool

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func findBreaks(A []int) []int {
	var C []int
	for i := 1; i <= n+1; i++ {
		if abs(A[i]-A[i-1]) != 1 {
			C = append(C, i)
		}
	}
	return C
}

func isSorted(A []int) bool {
	for i := 1; i <= n; i++ {
		if A[i] != i {
			return false
		}
	}
	return true
}

func rev(A []int, l, r int) {
	for i, j := l, r; i < j; i, j = i+1, j-1 {
		A[i], A[j] = A[j], A[i]
	}
}

func getCandidates(A []int, C []int) []Command {
	candsMap := make(map[int]bool)
	var cands []Command

	addCand := func(l, r int) {
		if l >= 1 && r <= n && l < r {
			key := l*2000 + r
			if !candsMap[key] {
				candsMap[key] = true
				cands = append(cands, Command{l, r})
			}
		}
	}

	for i := 0; i < len(C); i++ {
		for j := i+1; j < len(C); j++ {
			addCand(C[i], C[j]-1)
		}
	}

	for _, c := range C {
		if c >= 1 && c <= n {
			t1, t2 := A[c-1]+1, A[c-1]-1
			for r := c; r <= n; r++ {
				if A[r] == t1 || A[r] == t2 {
					addCand(c, r)
				}
			}
		}
		if c-1 >= 1 && c-1 <= n {
			t3, t4 := A[c]+1, A[c]-1
			for l := 1; l <= c-1; l++ {
				if A[l] == t3 || A[l] == t4 {
					addCand(l, c-1)
				}
			}
		}
	}
	return cands
}

func dfs(depth int, maxDepth int) {
	if found {
		return
	}
	if isSorted(A) {
		found = true
		return
	}
	if depth == maxDepth {
		return
	}

	C := findBreaks(A)
	if len(C) > (maxDepth-depth)*2 {
		return
	}

	if maxDepth-depth == 1 {
		if len(C) == 2 {
			l, r := C[0], C[1]-1
			if l < r {
				rev(A, l, r)
				if isSorted(A) {
					ans = append(ans, Command{l, r})
					found = true
					return
				}
				rev(A, l, r)
			}
		}
		return
	}

	cands := getCandidates(A, C)
	for _, cand := range cands {
		l, r := cand.l, cand.r
		rev(A, l, r)
		ans = append(ans, Command{l, r})
		dfs(depth+1, maxDepth)
		if found {
			return
		}
		ans = ans[:len(ans)-1]
		rev(A, l, r)
	}
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Fscan(reader, &n)
	A = make([]int, n+2)
	A[0] = 0
	A[n+1] = n + 1
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &A[i])
	}

	for maxDepth := 0; maxDepth <= 3; maxDepth++ {
		dfs(0, maxDepth)
		if found {
			fmt.Println(len(ans))
			for i := len(ans) - 1; i >= 0; i-- {
				fmt.Printf("%d %d\n", ans[i].l, ans[i].r)
			}
			return
		}
	}
}
```