```go
package main

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

type FastReader struct {
	r *bufio.Reader
}

func NewFastReader() *FastReader {
	return &FastReader{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fr *FastReader) NextInt() int {
	sign, val := 1, 0
	b, err := fr.r.ReadByte()
	for (b < '0' || b > '9') && b != '-' {
		if err != nil {
			return 0
		}
		b, err = fr.r.ReadByte()
	}
	if b == '-' {
		sign = -1
		b, err = fr.r.ReadByte()
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int(b-'0')
		b, err = fr.r.ReadByte()
		if err != nil {
			break
		}
	}
	return sign * val
}

type Edge struct {
	to int
	ei int
}

type Frame struct {
	v, p, e int
	entered bool
}

func main() {
	in := NewFastReader()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	n := in.NextInt()
	sub := make([]int64, n)
	for i := 0; i < n; i++ {
		sub[i] = int64(in.NextInt())
	}
	m := in.NextInt()
	x := make([]int, m)
	y := make([]int, m)
	adj := make([][]Edge, n)
	for i := 0; i < m; i++ {
		a := in.NextInt() - 1
		b := in.NextInt() - 1
		x[i] = a
		y[i] = b
		adj[a] = append(adj[a], Edge{to: b, ei: i})
		adj[b] = append(adj[b], Edge{to: a, ei: i})
	}

	flows := make([]int64, m)
	visited := make([]bool, n)
	impossible := false

	for start := 0; start < n; start++ {
		if visited[start] {
			continue
		}
		visited[start] = true
		stack := make([]Frame, 0, 2)
		stack = append(stack, Frame{v: start, p: -1, e: -1, entered: false})
		for len(stack) > 0 {
			f := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			if !f.entered {
				stack = append(stack, Frame{v: f.v, p: f.p, e: f.e, entered: true})
				for _, ed := range adj[f.v] {
					if !visited[ed.to] {
						visited[ed.to] = true
						stack = append(stack, Frame{v: ed.to, p: f.v, e: ed.ei, entered: false})
					}
				}
			} else {
				if f.p != -1 {
					sumV := sub[f.v]
					sub[f.p] += sumV
					if x[f.e] == f.p && y[f.e] == f.v {
						flows[f.e] = sumV
					} else {
						flows[f.e] = -sumV
					}
				} else {
					if sub[f.v] != 0 {
						impossible = true
						// No need to continue computing flows further
					}
				}
			}
			if impossible {
				break
			}
		}
		if impossible {
			break
		}
	}

	if impossible {
		fmt.Fprintln(out, "Impossible")
		return
	}
	fmt.Fprintln(out, "Possible")
	for i := 0; i < m; i++ {
		fmt.Fprintln(out, flows[i])
	}
}
```