anchor.diff:      let freeList = Queue<int> ()
       let correlations = dictPlus [] : Dictionary<Guid, int>
       
  -    member this.Components
  -        with get () = components
  -    
  -    member this.FreeIndex
  -        with get () = freeIndex
  +    member this.Components with get () = components and internal set value = components <- value
  +    member this.FreeIndex with get () = freeIndex and internal set value = freeIndex <- value
  +    member internal this.FreeList with get () = freeList
  +    member internal this.Correlations with get () = correlations
   
       member this.GetComponentIndex entityId =
           let (found, index) = correlations.TryGetValue entityId
  
positive.code:     (correlatedSystemNames : string array) =
      inherit SystemCorrelated<'t, 'w> ()
  
      let mutable components = [||] : 't array
      let mutable freeIndex = 0
      let mutable junctionsOpt = None : Dictionary<string, 'w System> option
      let freeList = Queue<int> ()
      let correlations = dictPlus [] : Dictionary<Guid, int>
  
      member this.GetJunctions getSystem (ecs : 'w Ecs) =
          match junctionsOpt with
  
negative.code:             junctions
  
      override this.Register entityId getSystem ecs =
          match Dictionary.tryGetValue entityId this.Correlations with
          | (false, _) ->
              let junctions = this.GetJunctions getSystem ecs
              let comp = this.Junction junctions entityId ecs
              if this.FreeList.Count = 0 then
                  if this.FreeIndex < this.Components.Length - 1 then
                      this.Components.[this.FreeIndex] <- comp
                      this.FreeIndex <- inc this.FreeIndex
                  else
                      let arr = Array.zeroCreate (this.Components.Length * 2)
                      this.Components.CopyTo (arr, 0)
                      this.Components <- arr
                      this.Components.[this.FreeIndex] <- comp
                      this.FreeIndex <- inc this.FreeIndex
                  let index = dec this.FreeIndex
                  this.Correlations.Add (entityId, index)
                  index
              else
                  let index = this.FreeList.Dequeue ()
                  this.Components.[index] <- comp
                  index
          | (true, index) ->
              let mutable comp = this.Components.[index]
              comp.RefCount <- inc comp.RefCount
              index
  
      override this.Unregister entityId =
          match this.Correlations.TryGetValue entityId with
          | (true, index) ->
              if index <> this.FreeIndex then
                  this.Components.[index].RefCount <- dec this.Components.[index].RefCount
                  if this.Components.[index].RefCount = 0 then this.FreeList.Enqueue index
              else this.FreeIndex <- dec this.FreeIndex
              true
          | (false, _) -> false
  
  