public unsafe Chunk *GetChunkWithEmptySlots(int *sharedComponentDataIndices, int numSharedComponents)
        {
            uint  hashCode = this.GetHashCode(sharedComponentDataIndices, numSharedComponents);
            Node *buckets  = this.buckets + ((hashCode & this.hashMask) * sizeof(Node));
            Node *nodePtr2 = this.buckets + (this.hashMask * sizeof(Node));

            while (true)
            {
                Chunk *chunkFromEmptySlotNode;
                if (buckets.IsFree())
                {
                    chunkFromEmptySlotNode = null;
                }
                else
                {
                    if (!(!buckets.IsDeleted() && buckets.CheckEqual(hashCode, sharedComponentDataIndices, numSharedComponents)))
                    {
                        buckets++;
                        if (buckets <= nodePtr2)
                        {
                            continue;
                        }
                        buckets = this.buckets;
                        continue;
                    }
                    chunkFromEmptySlotNode = ArchetypeManager.GetChunkFromEmptySlotNode(buckets->list.Begin);
                }
                return(chunkFromEmptySlotNode);
            }
        }
        private unsafe void Grow()
        {
            uint unoccupiedNodes = 0;
            int  num4            = 0;

            while (true)
            {
                if (num4 > this.hashMask)
                {
                    int   count   = (int)((this.hashMask + 1) * (this.ShouldGrow(unoccupiedNodes) ? 2 : 1));
                    Node *buckets = this.buckets;
                    int   num3    = ((int)this.hashMask) + 1;
                    this.Init(count);
                    Node *nodePtr2 = this.buckets + (this.hashMask * sizeof(Node));
                    int   num5     = 0;
                    while (true)
                    {
                        if (num5 >= num3)
                        {
                            UnsafeUtility.Free((void *)buckets, Allocator.Persistent);
                            return;
                        }
                        Node *nodePtr3 = buckets + num5;
                        if (!nodePtr3.IsDeleted() && !nodePtr3.IsFree())
                        {
                            uint  hash     = nodePtr3->hash;
                            Node *nodePtr4 = this.buckets + ((hash & this.hashMask) * sizeof(Node));
                            while (true)
                            {
                                if (nodePtr4.IsFree())
                                {
                                    nodePtr4[0] = nodePtr3[0];
                                    nodePtr4->list.Next.Prev = &nodePtr4->list;
                                    nodePtr4->list.Prev.Next = &nodePtr4->list;
                                    this.emptyNodes--;
                                    break;
                                }
                                nodePtr4++;
                                if (nodePtr4 > nodePtr2)
                                {
                                    nodePtr4 = this.buckets;
                                }
                            }
                        }
                        num5++;
                    }
                }
                if (((this.buckets + num4)).IsFree() || ((this.buckets + num4)).IsDeleted())
                {
                    unoccupiedNodes++;
                }
                num4++;
            }
        }
        private unsafe void AddMultiple(UnsafeLinkedListNode *list)
        {
            Chunk *chunkPtr = ref ArchetypeManager.GetChunkFromEmptySlotNode(list.Begin);
            uint   hashCode = this.GetHashCode(chunkPtr->SharedComponentValueArray, chunkPtr->Archetype.NumSharedComponents);
            int *  sharedComponentValueArray = chunkPtr->SharedComponentValueArray;
            int    numSharedComponents       = chunkPtr->Archetype.NumSharedComponents;
            Node * buckets  = this.buckets + ((hashCode & this.hashMask) * sizeof(Node));
            Node * nodePtr2 = this.buckets + (this.hashMask * sizeof(Node));
            Node * nodePtr3 = null;

            while (true)
            {
                if (buckets.IsFree())
                {
                    if (nodePtr3 == null)
                    {
                        nodePtr3 = buckets;
                        this.emptyNodes--;
                    }
                    nodePtr3->hash = hashCode;
                    UnsafeLinkedListNode.InitializeList(&nodePtr3->list);
                    UnsafeLinkedListNode.InsertListBefore(nodePtr3->list.End, list);
                    if (this.ShouldGrow(this.emptyNodes))
                    {
                        this.Grow();
                    }
                    break;
                }
                if (!buckets.IsDeleted())
                {
                    if (buckets.CheckEqual(hashCode, sharedComponentValueArray, numSharedComponents))
                    {
                        UnsafeLinkedListNode.InsertListBefore(buckets->list.End, list);
                        break;
                    }
                }
                else if (nodePtr3 == null)
                {
                    nodePtr3 = buckets;
                }
                buckets++;
                if (buckets > nodePtr2)
                {
                    buckets = this.buckets;
                }
            }
        }
        public unsafe void Add(Chunk *chunk)
        {
            int * sharedComponentValueArray = chunk.SharedComponentValueArray;
            int   numSharedComponents       = chunk.Archetype.NumSharedComponents;
            uint  hashCode = this.GetHashCode(sharedComponentValueArray, numSharedComponents);
            Node *buckets  = this.buckets + ((hashCode & this.hashMask) * sizeof(Node));
            Node *nodePtr2 = this.buckets + (this.hashMask * sizeof(Node));
            Node *nodePtr3 = null;

            while (true)
            {
                if (buckets.IsFree())
                {
                    if (nodePtr3 == null)
                    {
                        nodePtr3 = buckets;
                        this.emptyNodes--;
                    }
                    nodePtr3->hash = hashCode;
                    UnsafeLinkedListNode.InitializeList(&nodePtr3->list);
                    nodePtr3->list.Add(&chunk.ChunkListWithEmptySlotsNode);
                    if (this.ShouldGrow(this.emptyNodes))
                    {
                        this.Grow();
                    }
                    break;
                }
                if (!buckets.IsDeleted())
                {
                    if (buckets.CheckEqual(hashCode, sharedComponentValueArray, numSharedComponents))
                    {
                        buckets->list.Add(&chunk.ChunkListWithEmptySlotsNode);
                        break;
                    }
                }
                else if (nodePtr3 == null)
                {
                    nodePtr3 = buckets;
                }
                buckets++;
                if (buckets > nodePtr2)
                {
                    buckets = this.buckets;
                }
            }
        }
 public unsafe void AppendFrom(ChunkListMap *src)
 {
     if (src.buckets != null)
     {
         Node *buckets = src.buckets;
         int   num     = ((int)src.hashMask) + 1;
         int   num2    = 0;
         while (true)
         {
             if (num2 >= num)
             {
                 break;
             }
             Node *nodePtr2 = buckets + num2;
             if (!nodePtr2.IsDeleted() && !nodePtr2.IsFree())
             {
                 this.AddMultiple(&nodePtr2->list);
             }
             num2++;
         }
     }
 }