For problem statement at 0-999/500-599/550-559/553/problemD.txt this is a correct solution, but verifier at 0-999/500-599/550-559/553/verifierD.go ends with case 8 failed: runtime error: exit status 2
panic: runtime error: slice bounds out of range [-1:]

goroutine 1 [running]:
main.main()
	/tmp/build-521896212/solution.go:139 +0x9d8

exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"container/heap"
	"fmt"
	"os"
)

var D []int

type Item struct {
	v int
	d int
}

type PriorityQueue []Item

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
	return int64(pq[i].d)*int64(D[pq[j].v]) < int64(pq[j].d)*int64(D[pq[i].v])
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueue) Push(x interface{}) {
	*pq = append(*pq, x.(Item))
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	*pq = old[0 : n-1]
	return item
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buffer := make([]byte, 1024*1024)
	scanner.Buffer(buffer, 10*1024*1024)

	scanInt := func() int {
		if !scanner.Scan() {
			return 0
		}
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	n := scanInt()
	if n == 0 {
		return
	}
	m := scanInt()
	k := scanInt()

	isFortress := make([]bool, n+1)
	for i := 0; i < k; i++ {
		isFortress[scanInt()] = true
	}

	adj := make([][]int, n+1)
	D = make([]int, n+1)
	for i := 0; i < m; i++ {
		u := scanInt()
		v := scanInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
		D[u]++
		D[v]++
	}

	inS := make([]bool, n+1)
	dS := make([]int, n+1)
	for i := 1; i <= n; i++ {
		if !isFortress[i] {
			inS[i] = true
		}
	}

	for i := 1; i <= n; i++ {
		if inS[i] {
			for _, v := range adj[i] {
				if inS[v] {
					dS[i]++
				}
			}
		}
	}

	pq := make(PriorityQueue, 0)
	for i := 1; i <= n; i++ {
		if inS[i] {
			pq = append(pq, Item{v: i, d: dS[i]})
		}
	}
	heap.Init(&pq)

	bestScoreNum := int64(-1)
	bestScoreDen := int64(1)
	bestStep := -1

	var order []int
	step := 0

	for pq.Len() > 0 {
		item := heap.Pop(&pq).(Item)
		u := item.v
		if !inS[u] || item.d != dS[u] {
			continue
		}

		if int64(item.d)*bestScoreDen > bestScoreNum*int64(D[u]) {
			bestScoreNum = int64(item.d)
			bestScoreDen = int64(D[u])
			bestStep = step
		}

		order = append(order, u)
		inS[u] = false
		step++

		for _, v := range adj[u] {
			if inS[v] {
				dS[v]--
				heap.Push(&pq, Item{v: v, d: dS[v]})
			}
		}
	}

	ans := order[bestStep:]
	fmt.Println(len(ans))
	out := bufio.NewWriter(os.Stdout)
	for i, v := range ans {
		if i > 0 {
			out.WriteString(" ")
		}
		fmt.Fprintf(out, "%d", v)
	}
	out.WriteString("\n")
	out.Flush()
}