package main

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

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 {
		return
	}

	readGraph := func() [][]bool {
		adj := make([][]bool, n+1)
		for i := 0; i <= n; i++ {
			adj[i] = make([]bool, n+1)
		}
		for i := 1; i <= n; i++ {
			next := i + 1
			if next > n {
				next = 1
			}
			adj[i][next] = true
			adj[next][i] = true
		}
		for i := 0; i < n-3; i++ {
			var u, v int
			fmt.Fscan(in, &u, &v)
			adj[u][v] = true
			adj[v][u] = true
		}
		return adj
	}

	sourceAdj := readGraph()
	targetAdj := readGraph()

	solve := func(adj [][]bool, isTarget bool) [][2]int {
		var flips [][2]int
		for {
			neighbors := []int{}
			for i := 2; i <= n; i++ {
				if adj[1][i] {
					neighbors = append(neighbors, i)
				}
			}
			found := false
			for i := 0; i < len(neighbors)-1; i++ {
				u := neighbors[i]
				v := neighbors[i+1]
				if v-u > 1 {
					x := -1
					for k := u + 1; k < v; k++ {
						if adj[u][k] && adj[v][k] {
							x = k
							break
						}
					}
					if isTarget {
						flips = append(flips, [2]int{1, x})
					} else {
						flips = append(flips, [2]int{u, v})
					}
					adj[u][v] = false
					adj[v][u] = false
					adj[1][x] = true
					adj[x][1] = true
					found = true
					break
				}
			}
			if !found {
				break
			}
		}
		return flips
	}

	sourceFlips := solve(sourceAdj, false)
	targetFlips := solve(targetAdj, true)

	totalFlips := len(sourceFlips) + len(targetFlips)
	fmt.Fprintln(out, totalFlips)
	for _, f := range sourceFlips {
		fmt.Fprintln(out, f[0], f[1])
	}
	for i := len(targetFlips) - 1; i >= 0; i-- {
		fmt.Fprintln(out, targetFlips[i][0], targetFlips[i][1])
	}
}