Problem: We have a connected undirected graph with N vertices and M edges. Edge i in this graph (1 \leq i \leq M) connects Vertex U_i and Vertex V_i bidirectionally. We are additionally given N integers D_1, D_2, ..., D_N.

Determine whether the conditions below can be satisfied by assigning a color - white or black - to each vertex and an integer weight between 1 and 10^9 (inclusive) to each edge in this graph. If the answer is yes, find one such assignment of colors and integers, too.

* There is at least one vertex assigned white and at least one vertex assigned black.
* For each vertex v (1 \leq v \leq N), the following holds.
* The minimum cost to travel from Vertex v to a vertex whose color assigned is different from that of Vertex v by traversing the edges is equal to D_v.



Here, the cost of traversing the edges is the sum of the weights of the edges traversed.

Constraints

* 2 \leq N \leq 100,000
* 1 \leq M \leq 200,000
* 1 \leq D_i \leq 10^9
* 1 \leq U_i, V_i \leq N
* The given graph is connected and has no self-loops or multiple edges.
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N M
D_1 D_2 ... D_N
U_1 V_1
U_2 V_2
\vdots
U_M V_M


Output

If there is no assignment satisfying the conditions, print a single line containing `-1`.

If such an assignment exists, print one such assignment in the following format:


S
C_1
C_2
\vdots
C_M


Here,

* the first line should contain the string S of length N. Its i-th character (1 \leq i \leq N) should be `W` if Vertex i is assigned white and `B` if it is assigned black.
* The (i + 1)-th line (1 \leq i \leq M) should contain the integer weight C_i assigned to Edge i.

Examples

Input

5 5
3 4 3 5 7
1 2
1 3
3 2
4 2
4 5


Output

BWWBB
4
3
1
5
2


Input

5 7
1 2 3 4 5
1 2
1 3
1 4
2 3
2 5
3 5
4 5


Output

-1


Input

4 6
1 1 1 1
1 2
1 3
1 4
2 3
2 4
3 4


Output

BBBW
1
1
1
2
1
1

Solution (in PYTHON3):

Solution:
import sys

input=sys.stdin.buffer.readline
sys.setrecursionlimit(2*10**5)

N,M=map(int,input().split())
D=list(map(int,input().split()))
edge=[[] for i in range(N)]
for i in range(M):
    u,v=map(int,input().split())
    edge[u-1].append((v-1,i))
    edge[v-1].append((u-1,i))

used=[False]*N
color=[-1 for i in range(N)]
C=[10**9 for i in range(M)]
for v in range(N):
    if not used[v]:
        for nv,id in edge[v]:
            if D[nv]<D[v]:
                break
        else:
            for nv,id in edge[v]:
                if D[nv]==D[v]:
                    C[id]=D[v]
                    used[v]=True
                    if not used[nv]:
                        color[nv]=0
                        color[v]=1
                        used[nv]=True
                    else:
                        color[v]=1-color[nv]
                    break
            else:
                exit(print(-1))
Edge=[]
for v in range(N):
    if not used[v]:
        used[v]=True
        for nv,id in edge[v]:
            if D[nv]<D[v]:
                C[id]=D[v]-D[nv]
                Edge.append((v,nv,id))
                break

parent=[-1]*N
for u,v,id in Edge:
    parent[u]=v

def Coloring(v):
    if color[v]!=-1:
        return color[v]
    else:
        color[v]=Coloring(parent[v])
        return color[v]

res=[""]*N
for i in range(N):
    if Coloring(i)==0:
        res[i]="W"
    else:
        res[i]="B"

print("".join(res))
for i in range(M):
    print(C[i])