anchor.diff:          comps
   
       member this.Read count (stream : FileStream) =
  +        let firstIndex = freeIndex
  +        let lastIndex = freeIndex + count
  +        match Seq.tryHead stores with
  +        | Some headStoreEntry ->
  +            while headStoreEntry.Value.Length <= lastIndex do
  +                this.Grow ()
  +        | None -> ()
           for storeEntry in stores do
               let store = storeEntry.Value
               store.Read count freeIndex stream
  -        freeIndex <- freeIndex + count
  +        freeIndex <- inc lastIndex
  +        (firstIndex, lastIndex)
   
   /// Describes a means to query components.
   and IQuery =
  
positive.code:     member this.ComponentNames = hashSetPlus HashIdentity.Structural stores.Keys
      member this.Terms = terms
  
      member this.Register (comps : Dictionary<string, obj>) =
          if freeList.Count > 0 then
              let index = Seq.head freeList
              freeList.Remove index |> ignore<bool>
              for compEntry in comps do
                  stores.[compEntry.Key].SetItem index compEntry.Value
              index
          else
              match Seq.tryHead stores with
              | Some headStoreEntry ->
                  let index = freeIndex
                  if index = headStoreEntry.Value.Length then
                      for storeEntry in stores do
                          storeEntry.Value.Grow ()
                  for compEntry in comps do
                      stores.[compEntry.Key].SetItem index compEntry.Value
                  freeIndex <- inc freeIndex
                  index
              | None ->
  
negative.code:     member this.RegisterArchetype archetypeId archetype =
          archetypes.Add (archetypeId, archetype)
  
      member this.RegisterEntity archetypeId =
          let archetype =
              match archetypes.TryGetValue archetypeId with
              | (true, archetype) -> archetype
              | (false, _) -> createArchetype archetypeId
          let entityRef = this.EntityRef
          let archetypeIndex = archetype.Register (dictPlus HashIdentity.Structural [])
          archetypeSlots.Add (entityRef.EntityId, { ArchetypeIndex = archetypeIndex; Archetype = archetype })
          entityRef
  
      member this.ReadComponents count archetypeId stream =
          let archetype =
              match archetypes.TryGetValue archetypeId with
              | (true, archetype) -> archetype
              | (false, _) -> createArchetype archetypeId
          let (firstIndex, lastIndex) = archetype.Read count stream
          let entityRefs = SegmentedArray.zeroCreate count
          for i in firstIndex .. lastIndex do
              let entityRef = this.EntityRef
              archetypeSlots.Add (entityRef.EntityId, { ArchetypeIndex = i; Archetype = archetype })
              entityRefs.[i - firstIndex] <- entityRef
          entityRefs
  
  and [<StructuralEquality; NoComparison; Struct>] EntityRef =
      { EntityId : uint64
  