anchor.diff:          for storeEntry in stores do
               storeEntry.Value.Grow ()
   
  -    member private this.AllocIndex () =
  -        if freeList.Count > 0 then
  -            let index = Seq.head freeList
  -            freeList.Remove index |> ignore<bool>
  -            index
  -        else
  -            match Seq.tryHead stores with
  -            | Some headStoreEntry ->
  -                let index = freeIndex
  -                if index = headStoreEntry.Value.Length then this.Grow ()
  -                freeIndex <- inc freeIndex
  +    member private this.AllocIndex entityId =
  +        let index =
  +            if freeList.Count > 0 then
  +                let index = Seq.head freeList
  +                freeList.Remove index |> ignore<bool>
                   index
  -            | None ->
  -                let index = freeIndex
  -                freeIndex <- inc freeIndex
  -                index
  +            else
  +                match Seq.tryHead stores with
  +                | Some headStoreEntry ->
  +                    let index = freeIndex
  +                    if index = headStoreEntry.Value.Length then this.Grow ()
  +                    freeIndex <- inc freeIndex
  +                    index
  +                | None ->
  +                    let index = freeIndex
  +                    freeIndex <- inc freeIndex
  +                    index
  +        entityIdStore.[index] <- { Active = true; EntityId = entityId }
  +        index
   
       member private this.FreeIndex index =
  +        entityIdStore.[index] <- { Active = false; EntityId = 0UL }
           if index = dec freeIndex
           then freeIndex <- dec freeIndex
           else freeList.Add index |> ignore<bool>
   
  -    member this.Register (comps : Dictionary<string, obj>) =
  -        let index = this.AllocIndex ()
  +    member this.Register (comps : Dictionary<string, obj>) entityId =
  +        let index = this.AllocIndex entityId
           for compEntry in comps do
               stores.[compEntry.Key].SetItem index compEntry.Value
           index
  
positive.code:             match archetypes.TryGetValue archetypeId with
              | (true, archetype) -> archetype
              | (false, _) -> createArchetype archetypeId
          let archetypeIndex = archetype.Register comps
          archetypeSlots.Add (entity.EntityId, { ArchetypeIndex = archetypeIndex; Archetype = archetype })
  
      member private this.UnregisterEntityInternal archetypeSlot entity =
  
negative.code:         if  not (archetypes.ContainsKey archetype.Id) &&
              Subquery.evalMany archetype.Id.Terms subqueries then
              archetypes.Add (archetype.Id, archetype)
  
      member this.IndexEntitySlots ecs =
          let entities = SegmentedList.make ()
          for archetypeEntry in archetypes do
              let archetype = archetypeEntry.Value
              for i in 0 .. dec archetype.Length do
                  let entityId = archetype.EntityIdStore.[i]
                  if entityId.Active then
                      SegmentedList.add { EntityId = entityId.EntityId; Ecs = ecs } entities
          entities
  
      member this.Iterate (statement : Statement<'c, 'w>, ?compName, ?world : 'w) : 'w =
          let mutable world = Option.getOrDefault Unchecked.defaultof<'w> world
  