```go
package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	readInt := func() int {
		scanner.Scan()
		val, _ := strconv.Atoi(scanner.Text())
		return val
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	A := make([]int, n+1)
	for i := 1; i <= n; i++ {
		A[i] = readInt()
	}

	var opsB [][]int
	var opsC [][]int

	addOp := func(cycles [][]int) {
		var b, c []int
		for _, cyc := range cycles {
			b = append(b, cyc...)
			c = append(c, cyc[1:]...)
			c = append(c, cyc[0])
		}
		opsB = append(opsB, b)
		opsC = append(opsC, c)
	}

	executeOp := func(b, c []int) {
		opsB = append(opsB, b)
		opsC = append(opsC, c)
	}

	var cycles2 [][]int
	var cycles3 [][]int
	var cycles4 [][]int

	visited := make([]bool, n+1)
	for i := 1; i <= n; i++ {
		if !visited[i] {
			curr := i
			var cyc []int
			for !visited[curr] {
				visited[curr] = true
				cyc = append(cyc, curr)
				curr = A[curr]
			}

			if len(cyc) >= 2 {
				idx := 0
				for len(cyc)-idx >= 6 {
					b := []int{cyc[idx], cyc[idx+1], cyc[idx+2], cyc[idx+3], cyc[idx+4]}
					c := []int{b[1], b[2], b[3], b[4], b[0]}
					executeOp(b, c)
					cyc[idx+4] = cyc[idx]
					idx += 4
				}
				remCyc := cyc[idx:]
				if len(remCyc) == 5 {
					addOp([][]int{remCyc})
				} else if len(remCyc) == 4 {
					cycles4 = append(cycles4, remCyc)
				} else if len(remCyc) == 3 {
					cycles3 = append(cycles3, remCyc)
				} else if len(remCyc) == 2 {
					cycles2 = append(cycles2, remCyc)
				}
			}
		}
	}

	for {
		if len(cycles2) >= 1 && len(cycles3) >= 1 {
			u := cycles2[len(cycles2)-1]
			cycles2 = cycles2[:len(cycles2)-1]
			v := cycles3[len(cycles3)-1]
			cycles3 = cycles3[:len(cycles3)-1]
			addOp([][]int{u, v})
		} else if len(cycles3) >= 2 {
			u := cycles3[len(cycles3)-1]
			cycles3 = cycles3[:len(cycles3)-1]
			v := cycles3[len(cycles3)-1]
			cycles3 = cycles3[:len(cycles3)-1]

			b := append([]int{}, u...)
			b = append(b, v[0], v[1])

			c := append([]int{}, u[1:]...)
			c = append(c, u[0])
			c = append(c, v[1], v[0])

			executeOp(b, c)
			cycles2 = append(cycles2, []int{v[0], v[2]})
		} else if len(cycles2) >= 2 {
			u := cycles2[len(cycles2)-1]
			cycles2 = cycles2[:len(cycles2)-1]
			v := cycles2[len(cycles2)-1]
			cycles2 = cycles2[:len(cycles2)-1]
			addOp([][]int{u, v})
		} else if len(cycles4) >= 1 {
			u := cycles4[len(cycles4)-1]
			cycles4 = cycles4[:len(cycles4)-1]
			addOp([][]int{u})
		} else if len(cycles3) >= 1 {
			u := cycles3[len(cycles3)-1]
			cycles3 = cycles3[:len(cycles3)-1]
			addOp([][]int{u})
		} else if len(cycles2) >= 1 {
			u := cycles2[len(cycles2)-1]
			cycles2 = cycles2[:len(cycles2)-1]
			addOp([][]int{u})
		} else {
			break
		}
	}

	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	fmt.Fprintln(writer, len(opsB))
	for i := 0; i < len(opsB); i++ {
		fmt.Fprintln(writer, len(opsB[i]))
		for j, x := range opsB[i] {
			if j > 0 {
				fmt.Fprint(writer, " ")
			}
			fmt.Fprint(writer, x)
		}
		fmt.Fprintln(writer)
		for j, x := range opsC[i] {
			if j > 0 {
				fmt.Fprint(writer, " ")
			}
			fmt.Fprint(writer, x)
		}
		fmt.Fprintln(writer)
	}
}
```