diff --git a/combinatorial_LR_parser.py b/combinatorial_LR_parser.py
index 3394106c902e5cd13713f6cacd005e15661d67db..9c9b533b533cb6fd82818f04d6b90b99ce596b7c 100644
--- a/combinatorial_LR_parser.py
+++ b/combinatorial_LR_parser.py
@@ -561,8 +561,6 @@ class TreeSerializer(Elaboratable):
         start_of_record = Signal(self.mem_address_width) # start of next/yet-unwritten node record, advanced only
                                                          # after each reduce
 
-        writepointer    = Signal(self.mem_address_width) # current pointer for in-progress writes
-
         mem = Memory(width=(self.item_width + 1), depth=32)
         m.submodules.parse_tree = wport = mem.write_port()
 
@@ -574,12 +572,14 @@ class TreeSerializer(Elaboratable):
 
 
         # Per-reduce registered signals:
-        number_remaining            = Signal(range(self.stack_depth))
         number_of_children          = Signal(range(self.stack_depth))
 
         reduce_rule_number          = Signal(self.item_width)
         item_created_by_reduce_rule = Signal(self.item_width)
 
+        # incremented each cycle
+        number_written              = Signal(range(self.stack_depth))
+        
 
         with m.FSM() as fsm:
 
@@ -589,8 +589,8 @@ class TreeSerializer(Elaboratable):
                 m.d.comb += self.ready_out.eq(0)
 
 
-                m.d.sync += writepointer.eq(2)
                 m.d.sync += start_of_record.eq(0)
+                m.d.sync += number_written.eq(0)
 
                 m.next="NODE"
 
@@ -598,17 +598,17 @@ class TreeSerializer(Elaboratable):
 
             with m.State("NODE"):
                 m.d.comb += self.ready_out.eq(1)
+
                 #m.d.sync += reduce_rule_number.eq(self.reduce_rule_number)
                 m.d.sync += item_created_by_reduce_rule.eq(self.item_created_by_reduce_rule)
 
                 with m.If(self.start_reduction == 1):
                     m.d.comb += self.memory_write_port.eq(self.destroyed_item_in)
-                    m.d.comb += self.memory_address_port.eq(writepointer)
+                    m.d.comb += self.memory_address_port.eq(start_of_record + 2)
                     m.d.comb += self.memory_write_enable.eq(1)
 
                     m.d.sync += number_of_children.eq(self.number_to_pop)
-                    m.d.sync += number_remaining.eq(self.number_to_pop)
-                    m.d.sync += writepointer.eq(writepointer + 1)
+                    m.d.sync += number_written.eq(1)
                     m.next = "SUBNODES"
 
 
@@ -616,14 +616,13 @@ class TreeSerializer(Elaboratable):
                 m.d.comb += self.ready_out.eq(0)
                 with m.If(self.destroyed_item_valid_in == 1):
                     m.d.comb += self.memory_write_port.eq(self.destroyed_item_in)
-                    m.d.comb += self.memory_address_port.eq(writepointer)
+                    m.d.comb += self.memory_address_port.eq(start_of_record + 2 + number_written)
                     m.d.comb += self.memory_write_enable.eq(1)
 
-                    m.d.sync += writepointer.eq(writepointer + 1)
-                    m.d.sync += number_remaining.eq(number_remaining - 1)
+                    m.d.sync += number_written.eq(number_written + 1)
 
 
-                with m.If(number_remaining == 1):
+                with m.If(number_written == number_of_children):
                     m.d.comb += self.memory_write_port.eq(item_created_by_reduce_rule)
                     m.d.comb += self.memory_address_port.eq(start_of_record)
 
@@ -632,10 +631,14 @@ class TreeSerializer(Elaboratable):
                     m.next = "FIXUP"
 
             with m.State("FIXUP"):
+                    m.d.comb += self.ready_out.eq(0)
+
                     m.d.comb += self.memory_write_port.eq(number_of_children)
                     m.d.comb += self.memory_address_port.eq(start_of_record + 1)
                     m.d.comb += self.memory_write_enable.eq(1)
-                    m.d.sync += start_of_record.eq(writepointer + 1)
+                    m.d.sync += start_of_record.eq(start_of_record + 2 + number_of_children)
+                    m.next = "NODE"
+