from random import *

class space:
    def __init__(self, position = (0, 0)):
        self.dna = [0]*9
        self.name ="s"
w = 10
h = 10
field = [[0]*w]*h
types = 0
dif = set()
active = set()
num = 0

for i in range(w):
    for j in range(h):
        field[i][j] = space(position=(i, j))

def nears(i, j):
    result = set()
    for x in {(i+1, j), (i-1, j), (i, j-1), (i, j+1)}:
        if -1 < x[0] < w and -1 < x[1] < h:
            if field[x[0], x[1]].dna != space().dna:
                result.add(x)
    return result

def empty(i, j):
    result = set()
    for x in {(i+1, j), (i-1, j), (i, j-1), (i, j+1)}:
        if -1 < x[0] < w and -1 < x[1] < h:
            if field[x[0]][x[1]].dna == space().dna:
                result.add(x)
    return result

def fill(object, i, j):
    a = list(field[i])
    a[j] = object
    field[i] = a

class being:
    def __init__(self, dna, memory, position = (0, 0)):
        global dif
        global types
        global num
        if str(dna) not in dif:
            dif.add(str(dna))
            dna[9] = types
            types += 1
        self.dna = dna
        self.age = 0
        self.max_age = dna[0] + randint(-dna[10], dna[1])
        self.hp = dna[2]
        self.prod_age = dna[3]
        self.prod_range = dna[4] + randint(-dna[5], dna[5])
        self.speed = dna[6]
        self.damage = dna[7]
        self.can_eat = memory[0]
        self.danger = memory[1]
        self.state = 6
        self.comfort_state = dna[8]
        self.memory = memory
        self.name = dna[9]
        self.prod_chance = dna[11]
        self.position = position
        self.index = num
        num += 1

    def update(self):
        global active
        self.age += 1
        if self.age > self.max_age:
            fill(space(), self.position[0], self.position[1])
            active.discard(self)
        if self.prod_age < self.age and self.state > self.comfort_state:
            self.produce()
        if self.state < self.comfort_state:
            pass

    def produce(self):
        global active
        a = list(empty(self.position[0], self.position[1]))
        if len(a) > 0 and randint(1, 100) < self.prod_chance:
            a = choice(a)
            fill(being(self.dna, self.memory, position = (a[0], a[1])), a[0], a[1])
            active.add(field[a[0]][a[1]])

start = [3, 1, 100, 2, 1, 0, 1, 0, 4, 0, 1, 70]
memory = [0, 0]

def Game(n = 100000):
    t = 0
    global field, types, dif, active, num

    field = [[0]*w]*h
    types = 0
    dif = set()
    active = set()
    num = 0

    for i in range(w):
        for j in range(h):
            field[i][j] = space(position=(i, j))

    fill(being(start, memory, position=(4, 4)), 4, 4)
    active.add(field[4][4])
    while True:
        t += 1
        for line in field:
            for x in line:
                print(x.name, end=" ")
            print()
        print()
        st = types
        print(len(active))
        if len(active) == 0:
            return
        for b in set(active):
            #print(b.name, b.index, b.age)
            b.update()
        nt = types
        if st != nt:
            print(dif)

        if t == n:
            break

while (input() != "0"):
    Game(n = 1000)