human
Berland scientists know that the Old Berland language had exactly n words. Those words had lengths of l1, l2, ..., ln letters. Every word consisted of two letters, 0 and 1. Ancient Berland people spoke quickly and didn’t make pauses between the words, but at the same time they could always understand each other perfectly. It was possible because no word was a prefix of another one. The prefix of a string is considered to be one of its substrings that starts from the initial symbol.

Help the scientists determine whether all the words of the Old Berland language can be reconstructed and if they can, output the words themselves.

Input

The first line contains one integer N (1 ≤ N ≤ 1000) — the number of words in Old Berland language. The second line contains N space-separated integers — the lengths of these words. All the lengths are natural numbers not exceeding 1000.

Output

If there’s no such set of words, in the single line output NO. Otherwise, in the first line output YES, and in the next N lines output the words themselves in the order their lengths were given in the input file. If the answer is not unique, output any.

Examples

Input

3
1 2 3

Output

YES
0
10
110

Input

3
1 1 1

Output

NO
assistant
#Here is Python code to determine whether all the words of the Old Berland language can be reconstructed and if they can, output the words themselves.

class Node():
  def __init__(self):
    self.child = dict()
    self.count = 0
    self.weight = 0

def addWord(root, s):
  s = ""
  tmp = root
  length = 0
  flag = False
  for i in range(s):
    if len(tmp.child) == 0:
      tmp.child[0] = Node()
      tmp = tmp.child[0]
    elif len(tmp.child) == 1:
      if tmp.child[0].count > 0:
        tmp.child[1] = Node()
        tmp = tmp.child[1]
        tmp.count+=1
      else:
        tmp = tmp.child[0]
    elif len(tmp.child) == 2:
      if tmp.child[0].count > 0 and tmp.child[1].count > 0:
        return True
      elif tmp.child[0].count == 0:
        tmp = tmp.child[0]
      else:
        tmp = tmp.child[1]
  tmp.count+=1
  return False

  for ch in s:
    length += 1
    if ch in tmp.child:
      tmp = tmp.child[ch]
      if tmp.count > 0:
        flag = True
      if length == len(s):
        flag = True
    else:
      tmp.child[ch] = Node()
      tmp = tmp.child[ch]
    tmp.weight+=1
  tmp.count += 1
  return flag

def find(root,s):
  tmp = root
  for ch in s:
    if ch in tmp.child:
      tmp = tmp.child[ch]
    else:
      return 0
  return tmp.weight

def isWord(node):
  return node.count != 0

def isEmpty(node):
  return len(node.child) == 0

def removeWord(root, s, level, size):
  if root == None:
    return False
  if level == size:
    if root.count > 0:
      root.count-=1
      return True
    return False
  ch = s[level]
  flag = removeWord(root.child[ch],s,level+1,size)
  if flag == True and isWord(root.child[ch]) == False and isEmpty(root.child[ch]):
    tmp = root.child[ch]
    del tmp
    del root.child[ch]
  return flag

n = int(input())
cur =  0
word = ["" for _ in range(n)]

def dfs(string, depth):
  global cur, n, ar, word

  if cur >= n:
    return 

  if ar[cur][0] == depth:
    word[ar[cur][1]] = string
    cur += 1
    return

  string += '0'
  dfs(string, depth + 1)

  string = string[:-1] + '1'
  dfs(string, depth + 1)

  string = string[:-1]

length = [int(i) for i in input().split()]
ar = [[length[i],i] for i in...