For problem statement at 1000-1999/1100-1199/1170-1179/1178/problemD.txt this is a correct solution, but verifier at 1000-1999/1100-1199/1170-1179/1178/verifierD.go ends with case 1 failed: expected:
37
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
10 11
11 12
12 13
13 14
14 15
15 16
16 17
17 18
18 19
19 20
20 21
21 22
22 23
23 24
24 25
25 26
26 27
27 28
28 29
29 30
30 31
31 32
1 32
1 17
2 18
3 19
4 20
5 21
 got:
37
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10
10 11
11 12
12 13
13 14
14 15
15 16
16 17
17 18
18 19
19 20
20 21
21 22
22 23
23 24
24 25
25 26
26 27
27 28
28 29
29 30
30 31
31 32
1 32
1 3
4 6
7 9
10 12
13 15 can you fix the verifier? ```go
package main

import (
	"fmt"
)

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

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

func isPrime(x int) bool {
	if x < 2 {
		return false
	}
	if x == 2 || x == 3 {
		return true
	}
	if x%2 == 0 || x%3 == 0 {
		return false
	}
	for i := 5; i*i <= x; i += 6 {
		if x%i == 0 || x%(i+2) == 0 {
			return false
		}
	}
	return true
}

func greedy(l []int, n int) [][]int {
	ls := len(l)
	pa := make([]bool, n+1)
	var m [][]int
	for i := 0; i < ls; i++ {
		u := l[i]
		if pa[u] {
			continue
		}
		for j := i + 1; j < ls; j++ {
			v := l[j]
			if pa[v] {
				continue
			}
			d := abs(u - v)
			md := min(d, n-d)
			if md != 1 {
				m = append(m, []int{min(u, v), max(u, v)})
				pa[u] = true
				pa[v] = true
				break
			}
		}
	}
	return m
}

func main() {
	var n int
	fmt.Scan(&n)
	start_k := 0
	if n%2 == 0 {
		start_k = 1
	}
	step := 2
	for k := start_k; k <= n/2+1; k += step {
		m := n + k
		if m > n*(n-1)/2 {
			break
		}
		if !isPrime(m) {
			continue
		}
		used := make([]bool, n+1)
		var matching [][]int
		for i := 1; i <= n; i += 3 {
			u := i
			v := i + 2
			if v > n {
				v -= n
			}
			if u == v {
				continue
			}
			a := min(u, v)
			b := max(u, v)
			d := b - a
			d2 := n - d
			if min(d, d2) == 1 {
				continue
			}
			if used[a] || used[b] {
				continue
			}
			matching = append(matching, []int{a, b})
			used[a] = true
			used[b] = true
		}
		var left []int
		for i := 1; i <= n; i++ {
			if !used[i] {
				left = append(left, i)
			}
		}
		lm1 := greedy(left, n)
		revleft := make([]int, len(left))
		copy(revleft, left)
		for i, j := 0, len(revleft)-1; i < j; i, j = i+1, j-1 {
			revleft[i], revleft[j] = revleft[j], revleft[i]
		}
		lm2 := greedy(revleft, n)
		var lm [][]int
		if len(lm1) > len(lm2) {
			lm = lm1
		} else {
			lm = lm2
		}
		total_match := len(matching) + len(lm)
		if total_match >= k {
			var chords [][]int
			for i := 0; len(chords) < k && i < len(matching); i++ {
				chords = append(chords, matching[i])
			}
			need := k - len(chords)
			for i := 0; i < need; i++ {
				chords = append(chords, lm[i])
			}
			var all_edges [][]int
			for i := 1; i < n; i++ {
				all_edges = append(all_edges, []int{i, i + 1})
			}
			all_edges = append(all_edges, []int{1, n})
			for _, p := range chords {
				all_edges = append(all_edges, p)
			}
			fmt.Println(m)
			for _, e := range all_edges {
				fmt.Printf("%d %d\n", e[0], e[1])
			}
			return
		}
	}
	fmt.Println(-1)
}
```