For problem statement at 0-999/500-599/510-519/510/problemE.txt this is a correct solution, but verifier at 0-999/500-599/510-519/510/verifierE.go ends with All tests passed! can you fix the verifier? ```go
package main

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

type Edge struct {
	to, rev, cap, flow int
}

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

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

	var n int
	fmt.Fscan(reader, &n)

	a := make([]int, n+1)
	var even, odd []int
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &a[i])
		if a[i]%2 == 0 {
			even = append(even, i)
		} else {
			odd = append(odd, i)
		}
	}

	if len(even) != len(odd) {
		fmt.Fprintln(writer, "Impossible")
		return
	}

	const maxA = 20005
	isPrime := make([]bool, maxA)
	for i := 2; i < maxA; i++ {
		isPrime[i] = true
	}
	for i := 2; i*i < maxA; i++ {
		if isPrime[i] {
			for j := i * i; j < maxA; j += i {
				isPrime[j] = false
			}
		}
	}

	s, t := 0, n+1
	graph := make([][]Edge, n+2)
	addEdge := func(u, v, cap int) {
		graph[u] = append(graph[u], Edge{v, len(graph[v]), cap, 0})
		graph[v] = append(graph[v], Edge{u, len(graph[u]) - 1, 0, 0})
	}

	for _, u := range even {
		addEdge(s, u, 2)
		for _, v := range odd {
			if isPrime[a[u]+a[v]] {
				addEdge(u, v, 1)
			}
		}
	}
	for _, v := range odd {
		addEdge(v, t, 2)
	}

	level := make([]int, n+2)
	ptr := make([]int, n+2)

	bfs := func() bool {
		for i := range level {
			level[i] = -1
		}
		level[s] = 0
		q := []int{s}
		for len(q) > 0 {
			u := q[0]
			q = q[1:]
			for _, e := range graph[u] {
				if e.cap-e.flow > 0 && level[e.to] == -1 {
					level[e.to] = level[u] + 1
					q = append(q, e.to)
				}
			}
		}
		return level[t] != -1
	}

	var dfs func(int, int) int
	dfs = func(u, pushed int) int {
		if pushed == 0 || u == t {
			return pushed
		}
		for ; ptr[u] < len(graph[u]); ptr[u]++ {
			idx := ptr[u]
			e := &graph[u][idx]
			if level[u]+1 != level[e.to] || e.cap-e.flow == 0 {
				continue
			}
			tr := dfs(e.to, min(pushed, e.cap-e.flow))
			if tr == 0 {
				continue
			}
			e.flow += tr
			graph[e.to][e.rev].flow -= tr
			return tr
		}
		return 0
	}

	maxFlow := 0
	for bfs() {
		for i := range ptr {
			ptr[i] = 0
		}
		for {
			pushed := dfs(s, 1<<30)
			if pushed == 0 {
				break
			}
			maxFlow += pushed
		}
	}

	if maxFlow != 2*len(even) {
		fmt.Fprintln(writer, "Impossible")
		return
	}

	adj := make([][]int, n+1)
	for _, u := range even {
		for _, e := range graph[u] {
			if e.to != s && e.to != t && e.flow == 1 {
				adj[u] = append(adj[u], e.to)
				adj[e.to] = append(adj[e.to], u)
			}
		}
	}

	visited := make([]bool, n+1)
	var tables [][]int
	for i := 1; i <= n; i++ {
		if !visited[i] {
			var cycle []int
			curr := i
			for {
				visited[curr] = true
				cycle = append(cycle, curr)
				found := false
				for _, next := range adj[curr] {
					if !visited[next] {
						curr = next
						found = true
						break
					}
				}
				if !found {
					break
				}
			}
			tables = append(tables, cycle)
		}
	}

	fmt.Fprintln(writer, len(tables))
	for _, table := range tables {
		fmt.Fprint(writer, len(table))
		for _, x := range table {
			fmt.Fprint(writer, " ", x)
		}
		fmt.Fprintln(writer)
	}
}
```