For problem statement at 1000-1999/1700-1799/1770-1779/1776/problemI.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1770-1779/1776/verifierI.go ends with All tests passed can you fix the verifier? ```go
package main

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

type Pt struct {
	x int64
	y int64
}

var pts []Pt

func area2(a, b, c int) int64 {
	p := pts[a]
	q := pts[b]
	r := pts[c]
	x1 := q.x - p.x
	y1 := q.y - p.y
	x2 := r.x - p.x
	y2 := r.y - p.y
	v := x1*y2 - y1*x2
	if v < 0 {
		v = -v
	}
	return v
}

func removeVertex(cur []int, v int) []int {
	for i, x := range cur {
		if x == v {
			return append(cur[:i], cur[i+1:]...)
		}
	}
	return cur
}

func bestMove(cur []int) int {
	m := len(cur)
	if m <= 3 {
		return cur[0]
	}
	bestVal := int64(1<<62 - 1)
	best := cur[1]

	w := make([]int, m)

	for cut := 0; cut < m; cut++ {
		for i := 0; i < m; i++ {
			w[i] = cur[(cut+i)%m]
		}

		A := w[0]
		B := w[m-1]
		k := m - 2

		odd := make([][]int64, k+2)
		even := make([][]int64, k+2)
		for i := 0; i < k+2; i++ {
			odd[i] = make([]int64, k+2)
			even[i] = make([]int64, k+2)
		}

		for i := 1; i <= k; i++ {
			odd[i][i] = area2(A, w[i], B)
			even[i][i] = 0
		}

		for length := 2; length <= k; length++ {
			for l := 1; l+length-1 <= k; l++ {
				r := l + length - 1

				xLeft := area2(A, w[l], w[l+1])
				oddL := xLeft + even[l+1][r]
				evenL := odd[l+1][r]

				xRight := area2(w[r-1], w[r], B)
				oddR := odd[l][r-1]
				evenR := even[l][r-1]
				if length%2 == 1 {
					oddR += xRight
				} else {
					evenR += xRight
				}

				if oddL < oddR {
					odd[l][r] = oddL
				} else {
					odd[l][r] = oddR
				}
				if evenL < evenR {
					even[l][r] = evenL
				} else {
					even[l][r] = evenR
				}
			}
		}

		if odd[1][k] < bestVal {
			bestVal = odd[1][k]
			best = w[1]
		}
		if even[1][k] < bestVal {
			bestVal = even[1][k]
			best = w[k]
		}
	}

	return best
}

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
	}

	pts = make([]Pt, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(in, &pts[i].x, &pts[i].y)
	}

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

	helpAlberto := n%2 == 0
	if helpAlberto {
		fmt.Fprintln(out, "Alberto")
	} else {
		fmt.Fprintln(out, "Beatrice")
	}
	out.Flush()

	ourTurn := helpAlberto

	for len(cur) > 2 {
		if ourTurn {
			mv := bestMove(cur)
			fmt.Fprintln(out, mv)
			out.Flush()
			cur = removeVertex(cur, mv)
		} else {
			var mv int
			if _, err := fmt.Fscan(in, &mv); err != nil {
				return
			}
			if mv < 0 {
				return
			}
			cur = removeVertex(cur, mv)
		}
		ourTurn = !ourTurn
	}
}
```