output_description: 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.
  
  * * *
input_description: 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
attempt: import sys
  
  read = sys.stdin.buffer.read
  readline = sys.stdin.buffer.readline
  readlines = sys.stdin.buffer.readlines
  
  import itertools
  
  N = int(readline())
  A = list(map(int, readline().split()))
  B = list(map(int, readline().split()))
  
  
  class BinaryIndexedTree:
      def __init__(self, seq):
          self.size = len(seq)
          self.depth = self.size.bit_length()
          self.build(seq)
  
      def build(self, seq):
          data = seq
          size = self.size
          for i, x in enumerate(data):
              j = i + (i & (-i))
              if j < size:
                  data[j] += data[i]
          self.data = data
  
      def __repr__(self):
          return self.data.__repr__()
  
      def get_sum(self, i):
          data = self.data
          s = 0
          while i:
              s += data[i]
              i -= i & -i
          return s
  
      def add(self, i, x):
          data = self.data
          size = self.size
          while i < size:
              data[i] += x
              i += i & -i
  
      def find_kth_element(self, k):
          data = self.data
          size = self.size
          x, sx = 0, 0
          dx = 1 << (self.depth)
          for i in range(self.depth - 1, -1, -1):
              dx = 1 << i
              if x + dx >= size:
                  continue
              y = x + dx
              sy = sx + data[y]
              if sy < k:
                  x, sx = y, sy
          return x + 1
  
  
  def Inversion(seq):
      # seqは、1,2,...,Nの順列
      N = len(seq)
      bit = BinaryIndexedTree([0] * (N + 1))
      inv = N * (N - 1) // 2
      for x in seq:
          inv -= bit.get_sum(x)
          bit.add(x, 1)
      return inv
  
  
  INF = 10**9
  answer = INF
  for I in itertools.combinations(range(N), (N + 1) // 2):
      J = [j for j in range(N) if j not in I]
      ODD = [(B[i] if i & 1 else A[i], i) for i in I]
      EV = [(A[i] if i & 1 else B[i], i) for i in J]
      ODD.sort()
      EV.sort()
      ind = [0] * N
      seq = [0] * N
      for i in range(0, N, 2):
          seq[i], ind[i] = ODD[i // 2]
      for i in range(1, N, 2):
          seq[i], ind[i] = EV[i // 2]
      if not all(x <= y for x, y in zip(seq, seq[1:])):
          continue
      ind = [x + 1 for x in ind]
      n = Inversion(ind)
      if answer > n:
          answer = n
  
  if answer == INF:
      answer = -1
  print(answer)
  
problem_description: Statement
  
  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.
samples: [{"input": "5 5\n    3 4 3 5 7\n    1 2\n    1 3\n    3 2\n    4 2\n    4 5", "output": "BWWBB\n    4\n    3\n    1\n    5\n    2\n    \n\nAssume that we assign the colors and integers as the sample output, and let us\nconsider Vertex 5, for example. To travel from Vertex 5, which is assigned\nblack, to a vertex that is assigned white with the minimum cost, we should\nmake these moves: Vertex 5 \\to Vertex 4 \\to Vertex 2. The total cost of these\nmoves is 7, which satisfies the condition. We can also verify that the\ncondition is satisfied for other vertices.\n\n* * *"}, {"input": "5 7\n    1 2 3 4 5\n    1 2\n    1 3\n    1 4\n    2 3\n    2 5\n    3 5\n    4 5", "output": "-1\n    \n\n* * *"}, {"input": "4 6\n    1 1 1 1\n    1 2\n    1 3\n    1 4\n    2 3\n    2 4\n    3 4", "output": "BBBW\n    1\n    1\n    1\n    2\n    1\n    1"}]