#r = "800000000003600000070090200050007000000045700000100030001000068008500010090000400"
#r = "100007090030020008009600500005300900010080002600004000300000010040000007007000300"
#r = "000308000000000000306000901900504002005297300000000000080602010460000097102000805"
r = "040006000600320590702000080069010000000809000000070960090000105013052009000400020"

b_org = map(int, list(r))
b = map(int, list(r))

def print_board(b):
  for i in range(9):
    print "%s%s%s %s%s%s %s%s%s" % tuple(b[i*9:i*9+9])
    if i in (2, 5):
      print
  print

def h_neighbours(z):
  o = (z//9)*9
  l = [o+i for i in range(9)]
  return l

def v_neighbours(z):
  o = z%9
  l = [o+i*9 for i in range(9)]
  return l

def b_neighbours(z):
  x, y = (z//3)%3, (z//27)
  o = x*3+y*27
  l = [o+i for i in (0, 1, 2, 9, 10, 11, 18, 19, 20)]
  return l

def all_neighbours(z):
  l = set(h_neighbours(z) + v_neighbours(z) + b_neighbours(z))
  l.remove(z)
  return l

def placable(b, z, n):
  if b[z] != 0: return False
  for p in all_neighbours(z):
    if b[p] == n:
      return False
  return True

def possible_list(b, z):
  return  [i for i in range(1,10) if placable(b, z, i)]


def get_placables_and_choices(b):
  _t = []
  for i in range(81):
    l = possible_list(b, i)
    if len(l) > 0:
      _t.append((len(l), i, possible_list(b, i)))
  _t.sort()

  placables = [i[1] for i in _t]
  choices = {}
  for i in _t:
    choices[i[1]] = i[2]

  return placables, choices



while 1:
  print_board(b)

  placables, choices = get_placables_and_choices(b)

  determined = set()

  for place in placables:
    if len(choices[place]) == 1:
      determined.add((place, choices[place][0]))
      continue
    for fn in (h_neighbours, v_neighbours, b_neighbours):
      tb = []
      for i in fn(place):
        tb += choices.get(i, [])
      for c in choices[place]:
        if tb.count(c) == 1:
          determined.add((place, c))

  #print placables
  print choices
  print determined
  if not determined: break
  for at, num in determined: b[at] = num



"""
import random

rel_off = [0, 1, 2, 9, 10, 11, 18, 19, 20]
blk_off = [0, 3, 6, 27, 30, 33, 54, 57, 60]


def print_board(b):
  for i in range(9):
    print "%s%s%s %s%s%s %s%s%s" % tuple(b[i*9:i*9+9])
    if i in (2, 5):
      print
  print ""



#for i in range(9):
#  for d in io:
#    b[so[i]+d] = i

def horizontal_ok(b, z, n):
  o = (z//9)*9
  for i in range(9):
    if b[o+i] == n:
      return False
  return True

def vertical_ok(b, z, n):
  o = z%9
  for i in range(9):
    if b[o+i*9] == n:
      return False
  return True

c = 1

while 1:
  b = [0,]*81
  for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]:
    for i in range(9):
      random.shuffle(rel_off)
      for j in range(9):
        z = blk_off[i] + rel_off[j]
        if b[z] != 0: continue
        if horizontal_ok(b, z, n) and vertical_ok(b, z, n):
          b[z] = n
          break
  #print_board(b)
  if b.count(0) == 0: break
  c += 1

print_board(b)
#print c
"""



"""
r = "800000000003600000070090200050007000000045700000100030001000068008500010090000400"
#r = "100007090030020008009600500005300900010080002600004000300000010040000007007000300"

b_org = map(int, list(r))
b = map(int, list(r))

rel_off = [0, 1, 2, 9, 10, 11, 18, 19, 20]
blk_off = [0, 3, 6, 27, 30, 33, 54, 57, 60]


def print_board(b):
  for i in range(9):
    print "%s%s%s %s%s%s %s%s%s" % tuple(b[i*9:i*9+9])
    if i in (2, 5):
      print
  print ""

def horizontal_ok(b, z, n):
  o = (z//9)*9
  for i in range(9):
    if b[o+i] == n:
      return False
  return True

def vertical_ok(b, z, n):
  o = z%9
  for i in range(9):
    if b[o+i*9] == n:
      return False
  return True

def inblock_ok(b, z, n):
  x, y = (z//3)%3, (z//27)
  o = x*3+y*27
  for i in range(9):
    if b[o+rel_off[i]] == n:
      return False
  return True

def placable(b, z, n):
  if b[z] != 0: return False
  if not horizontal_ok(b, z, n): return False
  if not vertical_ok(b, z, n): return False
  if not inblock_ok(b, z, n): return False
  return True

print_board(b_org)

pt = 0

def challenge(b, pt):
  while pt <= 80:
    if b[pt] == 0:
      break
    pt += 1

  if pt > 80:
    print_board(b)
    print "GOAL"
    return

  choices = [i for i in range(1,10) if placable(b, pt, i)]
  for c in choices:
    b[pt] = c
    challenge(b, pt+1)
  b[pt] = 0
  return


challenge(b, 0)

"""


"""



def get_neighbours(z):
  rel_off = [0, 1, 2, 9, 10, 11, 18, 19, 20]
  n = set()
  #horizontal
  o = (z//9)*9
  for i in range(9):
    n.add(o+i)
  #vertical
  o = z%9
  for i in range(9):
    n.add(o+i*9)
  #in_block
  x, y = (z//3)%3, (z//27)
  o = x*3+y*27
  for i in range(9):
    n.add(o+rel_off[i])
  n.remove(z)
  return n

def placable(b, z, n):
  if b[z] != 0: return False
  for zz in neighbour_table[z]:
    if b[zz] == n: return False
  return True

def possible_list(b, z):
  return  [i for i in range(1,10) if placable(b, z, i)]

neighbour_table = {}
for i in range(81):
  neighbour_table[i] = get_neighbours(i)



def getprint_boardlacables_and_choices(b):
  _t = []
  for i in range(81):
    l = possible_list(b, i)
    if len(l) > 0:
      _t.append((len(l), i, possible_list(b, i)))
  _t.sort()

  placables = [i[1] for i in _t]
  choices = {}
  for i in _t:
    choices[i[1]] = i[2]

  return placables, choices



while 1:

  placables, choices = getprint_boardlacables_and_choices(b)

  t = placables[0]

  if len(choices[t]) == 1:
    print "place %d in %d for sure" % (choices[t][0], t)
    b[t] = choices[t][0]
    placables, choices = getprint_boardlacables_and_choices(b)
    continue

  print "undecidable. try if placing something detarmines something else.."
  print len(placables)
  for pl in placables:
    for pn in choices[pl]:
      #print pl, pn
      b2 = list(b)
      b2[pl] = pn
      placables2, choices2= getprint_boardlacables_and_choices(b2)
      #print len(placables2)
  break

print_board(b_org)
print_board(b)

for p in [57, 58, 59, 66, 76, 77]:
  print p, choices[p]
"""