For problem statement at 1000-1999/1700-1799/1770-1779/1773/problemA.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1770-1779/1773/verifierA.go ends with test 1 case 4: candidate claims Possible but reference Impossible
input case:
n = 5
a = 5 1 4 2 3
exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < len(fs.data) && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < len(fs.data) && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func writePerm(w *bufio.Writer, p []int, n int) {
	for i := 1; i <= n; i++ {
		if i > 1 {
			w.WriteByte(' ')
		}
		w.WriteString(strconv.Itoa(p[i]))
	}
	w.WriteByte('\n')
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}
	t := fs.NextInt()

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer w.Flush()

	for ; t > 0; t-- {
		n := fs.NextInt()
		sigma := make([]int, n+1)
		for pos := 1; pos <= n; pos++ {
			x := fs.NextInt()
			sigma[x] = pos
		}

		if n == 1 {
			w.WriteString("Impossible\n")
			continue
		}

		if n == 2 {
			if sigma[1] == 1 && sigma[2] == 2 {
				w.WriteString("Possible\n")
				w.WriteString("2 1\n")
				w.WriteString("2 1\n")
			} else {
				w.WriteString("Impossible\n")
			}
			continue
		}

		visited := make([]bool, n+1)
		order := make([]int, 0, n)
		forbidden := make([]bool, n+1)

		for i := 1; i <= n; i++ {
			if visited[i] {
				continue
			}
			cur := i
			length := 0
			for !visited[cur] {
				visited[cur] = true
				order = append(order, cur)
				length++
				cur = sigma[cur]
			}
			if length >= 2 && length <= n-1 {
				forbidden[n-length+1] = true
			}
		}

		k := 0
		for s := 2; s <= n-1; s++ {
			if !forbidden[s] {
				k = s
				break
			}
		}

		if k == 0 {
			w.WriteString("Impossible\n")
			continue
		}

		q := make([]int, n+1)
		for idx, x := range order {
			q[x] = order[(idx+k)%n]
		}

		p := make([]int, n+1)
		for i := 1; i <= n; i++ {
			p[q[i]] = sigma[i]
		}

		w.WriteString("Possible\n")
		writePerm(w, p, n)
		writePerm(w, q, n)
	}
}