description: A chess tournament will be held soon, where n chess players will take part. Every participant will play one game against every other participant. Each game ends in either a win for one player and a loss for another player, or a draw for both players.
  
  Each of the players has their own expectations about the tournament, they can be one of two types:
  
    1. a player wants not to lose any game (i. e. finish the tournament with zero losses); 
    2. a player wants to win at least one game. 
  
  
  
  You have to determine if there exists an outcome for all the matches such that all the players meet their expectations. If there are several possible outcomes, print any of them. If there are none, report that it's impossible.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 200) — the number of test cases.
  
  The first line of each test case contains one integer n (2 ≤ n ≤ 50) — the number of chess players.
  
  The second line contains the string s (|s| = n; s_i ∈ \{1, 2\}). If s_i = 1, then the i-th player has expectations of the first type, otherwise of the second type.
  
  Output
  
  For each test case, print the answer in the following format:
  
  In the first line, print NO if it is impossible to meet the expectations of all players.
  
  Otherwise, print YES, and the matrix of size n × n in the next n lines.
  
  The matrix element in the i-th row and j-th column should be equal to:
  
    * +, if the i-th player won in a game against the j-th player; 
    * -, if the i-th player lost in a game against the j-th player; 
    * =, if the i-th and j-th players' game resulted in a draw; 
    * X, if i = j. 
  
  Example
  
  Input
  
  
  3
  3
  111
  2
  21
  4
  2122
  
  
  Output
  
  
  YES
  X==
  =X=
  ==X
  NO
  YES
  X--+
  +X++
  +-X-
  --+X
solution: #Fast IO Region
  import collections
  import os
  import sys
  from datetime import date
  from io import BytesIO,IOBase
  BUFSIZE=8192
  class FastIO(IOBase):
      newlines=0
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  # Get out of main function
  def main():
      pass
  # decimal to binary
  def binary(n):
      return (bin(n).replace("0b", ""))
  # binary to decimal
  def decimal(s):
      return (int(s, 2))
  # power of a number base 2
  def pow2(n):
      p = 0
      while n > 1:
          n //= 2
          p += 1
      return (p)
  # if  number is prime in √n time
  def isPrime(n):
      if (n == 1):
          return (False)
      else:
          root = int(n ** 0.5)
          root += 1
          for i in range(2, root):
              if (n % i == 0):
                  return (False)
          return (True)
  # list to string ,no spaces
  def lts(l):
      s = ''.join(map(str, l))
      return s
  # String to list
  def stl(s):
      # for each character in string to list with no spaces -->
      l = list(s)
      # for space in string  -->
      # l=list(s.split(" "))
      return l
  # Returns list of numbers with a particular sum
  def sq(a, target, arr=[]):
      s = sum(arr)
      if (s == target):
          return arr
      if (s >= target):
          return
      for i in range(len(a)):
          n = a[i]
          remaining = a[i + 1:]
          ans = sq(remaining, target, arr + [n])
          if (ans):
              return ans
  # Sieve for prime numbers in a range
  def SieveOfEratosthenes(n):
      cnt = 0
      prime = [True for i in range(n + 1)]
      p = 2
      while (p * p <= n):
          if (prime[p] == True):
              for i in range(p * p, n + 1, p):
                  prime[i] = False
          p += 1
      for p in range(2, n + 1):
          if prime[p]:
              cnt += 1
              # print(p)
      return (cnt)
  # for positive integerse only
  def nCr(n, r):
      f = math.factorial
      return f(n) // f(r) // f(n - r)
  # 1000000007
  mod = int(1e9) + 7
  import math
  import statistics
  #import random
  from bisect import bisect_right
  #from fractions import Fraction
  #from collections import OrderedDict
  #from collections i
  # mport deque
  ########################                         mat=[[0 for i in range(n)] for j in range(m)]                      ########################
  ########################                         list.sort(key=lambda x:x[1]) for sorting a list according to second element in sublist            ########################
  ########################                         Speed: STRING < LIST < SET,DICTIONARY                      ########################
  ########################                         from collections import deque                              ########################
  ########################                         ASCII of A-Z= 65-90                                        ########################
  ########################                         ASCII of a-z= 97-122                                       ########################
  ########################                         d1.setdefault(key, []).append(value)                       ########################
  #sys.setrecursionlimit(500000)          #Gives memory limit exceeded if used a lot
  #import heapq
  for __ in range(int(input())):
      n=int(input())
      s=input()
      ans=[[0 for i in range(n)] for j in range(n)]
      l=[]
      for i in range(n):
          if(s[i]=="2"):
              l.append(i)
      if(len(l)<=2 and len(l)>0):
          print("NO")
      else:
          print("YES")
          for i in range(n):
              for j in range(n):
                  if(i==j):
                      ans[i][j]="X"
                  elif(s[i]=="1"):
                      ans[i][j]="="
                  else:
                      ans[i][j]="="
          for i in range(len(l)):
              if(i==len(l)-1):
                  ans[l[i]][l[0]]="+"
                  ans[l[0]][l[i]]="-"
              else:
                  ans[l[i]][l[i+1]]="+"
                  ans[l[i+1]][l[i]]="-"
          for c in ans:
              print("".join(map(str,c)))
  
  