Game-of-Life.masm

# GAME OF LIFE - and we can prove it

# Rules:

# 1. Any live cell with two or three live neighbours survives.

# 2. Any dead cell with three live neighbours becomes a live cell.

# 3. All other live cells die in the next generation. Similarly, all other dead cells stay dead.


# We store the initial stack - state of the universe
proc.storecellsn.16
   loc_store.0 drop
   loc_store.1 drop
   loc_store.2 drop
   loc_store.3 drop
   loc_store.4 drop
   loc_store.5 drop
   loc_store.6 drop
   loc_store.7 drop
   loc_store.8 drop
   loc_store.9 drop
   loc_store.10 drop
   loc_store.11 drop
   loc_store.12 drop
   loc_store.13 drop
   loc_store.14 drop
   loc_store.15 drop
end


# We load the final stack - state of the universe
proc.loadcellsnplus1.32
   loc_load.16
   loc_load.17
   loc_load.18
   loc_load.19
   loc_load.20
   loc_load.21
   loc_load.22
   loc_load.23
   loc_load.24
   loc_load.25
   loc_load.26
   loc_load.27
   loc_load.28
   loc_load.29
   loc_load.30
   loc_load.31
end


# We clear the stack by setting all to 0

proc.clearstack
    repeat.16
        drop
    end
end

# State transition for cell 0

proc.cell_0_transition.32
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.16 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.1
   loc_load.4
   loc_load.5

   # We load the cell itself to check its status
   loc_load.0

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.16 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.16 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.16 drop
        end
    end
end
# State transition for cell 1

proc.cell_1_transition.33
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.17 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.0
   loc_load.2
   loc_load.4
   loc_load.5
   loc_load.6

   # We load the cell itself to check its status
   loc_load.1

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.17 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.17 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.17 drop
        end
    end
end
# State transition for cell 2

proc.cell_2_transition.34
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.18 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.1
   loc_load.3
   loc_load.5
   loc_load.6
   loc_load.7

   # We load the cell itself to check its status
   loc_load.2

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.18 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.18 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.18 drop
        end
    end
end
# State transition for cell 3

proc.cell_3_transition.35
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.19 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.2
   loc_load.6
   loc_load.7

   # We load the cell itself to check its status
   loc_load.3

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.19 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.19 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.19 drop
        end
    end
end
# State transition for cell 4

proc.cell_4_transition.36
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.20 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.0
   loc_load.1
   loc_load.5
   loc_load.8
   loc_load.9

   # We load the cell itself to check its status
   loc_load.4

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.20 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.20 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.20 drop
        end
    end
end
# State transition for cell 5

proc.cell_5_transition.37
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.21 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.0
   loc_load.1
   loc_load.2
   loc_load.4
   loc_load.6
   loc_load.8
   loc_load.9
   loc_load.10

   # We load the cell itself to check its status
   loc_load.5

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.21 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.21 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.21 drop
        end
    end
end
# State transition for cell 6

proc.cell_6_transition.38
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.22 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.1
   loc_load.2
   loc_load.3
   loc_load.5
   loc_load.7
   loc_load.9
   loc_load.10
   loc_load.11

   # We load the cell itself to check its status
   loc_load.6

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.22 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.22 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.22 drop
        end
    end
end
# State transition for cell 7

proc.cell_7_transition.39
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.23 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.2
   loc_load.3
   loc_load.6
   loc_load.10
   loc_load.11

   # We load the cell itself to check its status
   loc_load.7

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.23 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.23 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.23 drop
        end
    end
end
# State transition for cell 8

proc.cell_8_transition.40
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.24 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.4
   loc_load.5
   loc_load.9
   loc_load.12
   loc_load.13

   # We load the cell itself to check its status
   loc_load.8

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.24 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.24 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.24 drop
        end
    end
end
# State transition for cell 9

proc.cell_9_transition.41
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.25 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.4
   loc_load.5
   loc_load.6
   loc_load.8
   loc_load.10
   loc_load.12
   loc_load.13
   loc_load.14

   # We load the cell itself to check its status
   loc_load.9

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.25 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.25 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.25 drop
        end
    end
end
# State transition for cell 10

proc.cell_10_transition.42
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.26 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.5
   loc_load.6
   loc_load.7
   loc_load.9
   loc_load.11
   loc_load.13
   loc_load.14
   loc_load.15

   # We load the cell itself to check its status
   loc_load.10

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.26 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.26 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.26 drop
        end
    end
end
# State transition for cell 11

proc.cell_11_transition.43
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.27 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.6
   loc_load.7
   loc_load.10
   loc_load.14
   loc_load.15

   # We load the cell itself to check its status
   loc_load.11

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.27 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.27 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.27 drop
        end
    end
end
# State transition for cell 12

proc.cell_12_transition.44
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.28 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.8
   loc_load.9
   loc_load.13

   # We load the cell itself to check its status
   loc_load.12

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.28 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.28 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.28 drop
        end
    end
end
# State transition for cell 13

proc.cell_13_transition.45
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.29 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.8
   loc_load.9
   loc_load.10
   loc_load.12
   loc_load.14

   # We load the cell itself to check its status
   loc_load.13

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.29 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.29 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.29 drop
        end
    end
end
# State transition for cell 14

proc.cell_14_transition.46
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.30 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.9
   loc_load.10
   loc_load.11
   loc_load.13
   loc_load.15

   # We load the cell itself to check its status
   loc_load.14

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.30 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.30 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.30 drop
        end
    end
end
# State transition for cell 15

proc.cell_15_transition.47
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.31 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.10
   loc_load.11
   loc_load.14

   # We load the cell itself to check its status
   loc_load.15

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.31 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.31 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.31 drop
        end
    end
end
# State transition for cell 16

proc.cell_16_transition.48
   
   # We assume a cell is dead (0) in the next round until proven otherwise
   push.0
   loc_store.32 drop
    
   # We load all the cell's neighbours to check their status
   loc_load.12
   loc_load.13

   # We load the cell itself to check its status
   loc_load.16

   # Cell is alice (1) and might stay alive 

    if.true
        # We add all the cells possible neighbours (max 8) togther -> if sum >= 2 < 4 cell stays alive    
        repeat.7
            add
        end

        dup

        # We want to compare the sum with 2
        push.2
        eq

        if.true
            push.1
            loc_store.32 drop
        end

        # We want to compare the sum with 3
        push.3
        eq

        if.true
            push.1
            loc_store.32 drop
        end
    
    # Cell is dead (0) and might come alive   
    else

        repeat.7
            add
        end

        push.3
        eq

        if.true
            push.1
            loc_store.32 drop
        end
    end
end
    # Let's play


begin

     repeat.10
        exec.storecellsn
        exec.cell_0_transition exec.clearstack
        exec.cell_1_transition exec.clearstack
        exec.cell_2_transition exec.clearstack
        exec.cell_3_transition exec.clearstack
        exec.cell_4_transition exec.clearstack
        exec.cell_5_transition exec.clearstack
        exec.cell_6_transition exec.clearstack
        exec.cell_7_transition exec.clearstack
        exec.cell_8_transition exec.clearstack
        exec.cell_9_transition exec.clearstack
        exec.cell_10_transition exec.clearstack
        exec.cell_11_transition exec.clearstack
        exec.cell_12_transition exec.clearstack
        exec.cell_13_transition exec.clearstack
        exec.cell_14_transition exec.clearstack
        exec.cell_15_transition exec.clearstack
        exec.loadcellsnplus1
    end
end