990_F. Flow Control
You have to handle a very complex water distribution system. The system consists of n junctions and m pipes, i-th pipe connects junctions x_i and y_i.

The only thing you can do is adjusting the pipes. You have to choose m integer numbers f_1, f_2, ..., f_m and use them as pipe settings. i-th pipe will distribute f_i units of water per second from junction x_i to junction y_i (if f_i is negative, then the pipe will distribute |f_i| units of water per second from junction y_i to junction x_i). It is allowed to set f_i to any integer from -2 ⋅ 10^9 to 2 ⋅ 10^9.

In order for the system to work properly, there are some constraints: for every i ∈ [1, n], i-th junction has a number s_i associated with it meaning that the difference between incoming and outcoming flow for i-th junction must be exactly s_i (if s_i is not negative, then i-th junction must receive s_i units of water per second; if it is negative, then i-th junction must transfer |s_i| units of water per second to other junctions).

Can you choose the integers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied?

Input

The first line contains an integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of junctions.

The second line contains n integers s_1, s_2, ..., s_n (-10^4 ≤ s_i ≤ 10^4) — constraints for the junctions.

The third line contains an integer m (0 ≤ m ≤ 2 ⋅ 10^5) — the number of pipes.

i-th of the next m lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i) — the description of i-th pipe. It is guaranteed that each unordered pair (x, y) will appear no more than once in the input (it means that there won't be any pairs (x, y) or (y, x) after the first occurrence of (x, y)). It is guaranteed that for each pair of junctions there exists a path along the pipes connecting them.

Output

If you can choose such integer numbers f_1, f_2, ..., f_m in such a way that all requirements on incoming and outcoming flows are satisfied, then output "Possible" in the first line. Then output m lines, i-th line should contain f_i — the chosen setting numbers for the pipes. Pipes are numbered in order they appear in the input.

Otherwise output "Impossible" in the only line.

Examples

Input

4
3 -10 6 1
5
1 2
3 2
2 4
3 4
3 1


Output

Possible
4
-6
8
-7
7


Input

4
3 -10 6 4
5
1 2
3 2
2 4
3 4
3 1


Output

Impossible
```python
import sys
from time import time
t1 = time()
 
#sys.setrecursionlimit(300000)
 
def i_ints():
    return list(map(int, sys.stdin.readline().split()))
 
 
def main():
    limit =10**10
 
    n, = i_ints()
    s = [0] + i_ints()
    if sum(s):
        print("Impossible")
        return
    print("Possible")
 
    if n == limit: print(int(1000000*(time()-t1)))
 
    m, = i_ints()
    es = [i_ints() for _ in range(m)]
 
    if n == limit: print(int(1000000*(time()-t1)))
 
    nb = [[] for i in range(n+1)]
    for i, (x, y) in enumerate(es):
        nb[x].append((y, i, 1))
        nb[y].append((x, i, -1))
        
    if n == limit: print(int(1000000*(time()-t1)))
 
    f = [0] * m
    
    
    path = []
    def make_path():
        stack = []
        seen = [False] * (n+1)
        stack.append(1)
        seen[1] = True
        while stack:
            x = stack.pop()
            for y, i, factor in nb[x]:
                if not seen[y]:
                    seen[y] = True
                    stack.append(y)
                    path.append((x, y, i, factor))
                    
    make_path()
#    print(path)
    if n == limit: print(int(1000000*(time()-t1)))
 
    for x, y, i,factor in reversed(path):
        f[i] = factor * s[y]
        s[x] += s[y]
        s[y] = 0
    if n == limit: print(int(1000000*(time()-t1)))
    print("\n".join(map(str, f)))
        
    return
    
#    def walk_tree(x, seen):
#        seen.add(x)
#        for y, i, factor in nb[x]:
#            if y not in seen:
#                walk_tree(y, seen)
#                f[i] = factor * s[y]
#                s[x] += s[y]
#                s[y] = 0
#    walk_tree(1, set())
#
#    if n > limit: print(int(1000000*(time()-t1)))
#
#    print("\n".join(map(str, f)))
        
main()
    	 	 	  			 		    		   					
```