```go
package main

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

type Decision struct {
	cost  int
	strat int
	use_R int
}

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

	var n int
	if _, err := fmt.Fscan(in, &n); err != nil || n == 0 {
		return
	}

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

	sizes := []int{0}
	current_size := 1
	for i := n - 2; i >= 0; i-- {
		if d[i] == d[i+1] {
			current_size++
		} else {
			sizes = append(sizes, current_size)
			current_size = 1
		}
	}
	sizes = append(sizes, current_size)

	k := len(sizes) - 1
	DP_P := make([]Decision, k+1)
	DP_R := make([]Decision, k+1)
	DP_P[0] = Decision{0, 0, 0}
	DP_R[0] = Decision{0, 0, 0}

	for i := 1; i <= k; i++ {
		c := sizes[i]

		cost_R_P := 2*DP_P[i-1].cost + c
		cost_R_R := 2*DP_R[i-1].cost + c
		if cost_R_P <= cost_R_R {
			DP_R[i] = Decision{cost_R_P, 1, 0}
		} else {
			DP_R[i] = Decision{cost_R_R, 1, 2}
		}

		if c == 1 {
			DP_P[i] = DP_R[i]
		} else {
			cost2_P := 3*DP_P[i-1].cost + 2*c
			cost2_R := DP_P[i-1].cost + 2*DP_R[i-1].cost + 2*c
			best2 := cost2_P
			use_R_2 := 0
			if cost2_R < best2 {
				best2 = cost2_R
				use_R_2 = 2
			}

			cost3_P := 4*DP_P[i-1].cost + 2*c - 1
			cost3_R2 := 2*DP_P[i-1].cost + 2*DP_R[i-1].cost + 2*c - 1
			cost3_R4 := 4*DP_R[i-1].cost + 2*c - 1

			best3 := cost3_P
			use_R_3 := 0
			if cost3_R2 < best3 {
				best3 = cost3_R2
				use_R_3 = 2
			}
			if cost3_R4 < best3 {
				best3 = cost3_R4
				use_R_3 = 4
			}

			if best2 <= best3 {
				DP_P[i] = Decision{best2, 2, use_R_2}
			} else {
				DP_P[i] = Decision{best3, 3, use_R_3}
			}
		}
	}

	fmt.Fprintln(out, DP_P[k].cost)

	var solve_P func(i, S, T, A int)
	var solve_R func(i, S, T, A int)

	move_disks := func(cnt, S, T int) {
		for j := 0; j < cnt; j++ {
			fmt.Fprintln(out, S, T)
		}
	}

	solve_P = func(i, S, T, A int) {
		if i == 0 {
			return
		}
		c := sizes[i]
		dec := DP_P[i]

		if dec.strat == 1 {
			if dec.use_R == 0 {
				solve_P(i-1, S, A, T)
				move_disks(c, S, T)
				solve_P(i-1, A, T, S)
			} else {
				solve_R(i-1, S, A, T)
				move_disks(c, S, T)
				solve_R(i-1, A, T, S)
			}
		} else if dec.strat == 2 {
			if dec.use_R == 0 {
				solve_P(i-1, S, T, A)
				move_disks(c, S, A)
				solve_P(i-1, T, S, A)
				move_disks(c, A, T)
				solve_P(i-1, S, T, A)
			} else {
				solve_R(i-1, S, T, A)
				move_disks(c, S, A)
				solve_R(i-1, T, S, A)
				move_disks(c, A, T)
				solve_P(i-1, S, T, A)
			}
		} else if dec.strat == 3 {
			if dec.use_R == 0 {
				solve_P(i-1, S, T, A)
				move_disks(c-1, S, A)
				solve_P(i-1, T, A, S)
				move_disks(1, S, T)
				solve_P(i-1, A, S, T)
				move_disks(c-1, A, T)
				solve_P(i-1, S, T, A)
			} else if dec.use_R == 2 {
				solve_R(i-1, S, T, A)
				move_disks(c-1, S, A)
				solve_R(i-1, T, A, S)
				move_disks(1, S, T)
				solve_P(i-1, A, S, T)
				move_disks(c-1, A, T)
				solve_P(i-1, S, T, A)
			} else {
				solve_R(i-1, S, T, A)
				move_disks(c-1, S, A)
				solve_R(i-1, T, A, S)
				move_disks(1, S, T)
				solve_R(i-1, A, S, T)
				move_disks(c-1, A, T)
				solve_R(i-1, S, T, A)
			}
		}
	}

	solve_R = func(i, S, T, A int) {
		if i == 0 {
			return
		}
		c := sizes[i]
		dec := DP_R[i]
		if dec.use_R == 0 {
			solve_P(i-1, S, A, T)
			move_disks(c, S, T)
			solve_P(i-1, A, T, S)
		} else {
			solve_R(i-1, S, A, T)
			move_disks(c, S, T)
			solve_R(i-1, A, T, S)
		}
	}

	solve_P(k, 1, 3, 2)
}
```